PHP & Web Development Blogs

It's 2018, and you're a top-notch modern web developer, with a load of knowledge and tools right there at your disposal: Google and StackOverflow, debugger with a GUI, IDE with autocomplete, you name it. Occasionally, though, you still find yourself in a plain old text console on a remote server, or you have to do something without IDE, or there is no network connection... In such cases it might be helpful to feel comfortable in a simple terminal. In this post I'm going to list some switches for the PHP command that you can use to get information and some utilities.

Getting basic information about PHP

$ php -i
phpinfo()
PHP Version => 7.2.10-0ubuntu1

System => Linux awesome 4.18.0-10-generic #11-Ubuntu SMP Thu Oct 11 15:13:55 UTC 2018 x86_64
Build Date => Sep 13 2018 13:38:55
Server API => Command Line Interface
Virtual Directory Support => disabled
...

Full information about your PHP interpreter. Pipe the output to the Unix less command in order to get pagination and search: php -i | less. Type Q to exit the less shell. Some distros might lack less, in that case you may try php -i | more, which doesn't give you search but still has pagination.

Want a short summary of which PHP extensions you have? Just ask:

$ php -m
[PHP Modules]
calendar
Core
ctype
date
dom
ds
exif
...

More specific info about core and extensions' functions and classes

Full information about functions and classes provided by an extension:

$ php --re ds
Extension [ <persistent> extension #46 ds version 1.2.6 ] {

 - Dependencies {
 Dependency [ json (Required) ]
 Dependency [ spl (Required) ]
 }

 - Classes [11] {
 Interface [ <internal:ds> interface Ds\Hashable ] {

 - Constants [0] {
 }

 - Static properties [0] {
 }
...

Information on a specific class:

$ php --rc Ds\Vector
Class [ <internal:ds> <iterateable> final class Ds\Vector implements Ds\Sequence, Traversable, Countable, JsonSerializable, Ds\Collection ] {

 - Constants [1] {
 Constant [ public integer MIN_CAPACITY ] { 8 }
 }

 - Static properties [0] {
 }
...

Same for a function:

$ php --rf fopen
Function [ <internal:standard> function fopen ] {

 - Parameters [4] {
 Parameter #0 [ <required> $filename ]
 Parameter #1 [ <required> $mode ]
 Parameter #2 [ <optional> $use_include_path ]
 Parameter #3 [ <optional> $context ]
 }
}

Utilities

Ever found yourself creating a dummy PHP file of just a few lines - only to be run once and then deleted? The -a switch might be what you're looking for:

$ php -a
Interactive mode enabled

php > var_dump(join(", ", [1, 2, 3]));
php shell code:1:
string(7) "1, 2, 3"
php > 

It starts an interactive shell so you can type any PHP code and execute it straight away. Requires PHP to be compiled with readline support (most distros have that anyway).

Want a quick check for any parse/syntax errors in a PHP file? Use linter:

$ php -l test.php 
PHP Parse error: syntax error, unexpected 'array_shift' (T_STRING) in test.php on line 4
Errors parsing test.php

It has a web-server!

Yes! Just in case you missed it, as of PHP 5.4.0, the CLI SAPI provides a built-in web server. Want a quick look at a web page generated by an app? Here you go:

$ cd /my_application/document_root
$ php -S localhost:8000

Then open http://localhost:8000/ in your browser of choice and enjoy!

Hope you also have enjoyed this reading. Your feedback and questions are always appreciated!

Composer is a must-have tool for every PHP developer these days. This page is a simple breakdown of quick-install instructions.

How do I install composer?
   

. Use PHP to download the composer installer, place it in the current directory, and name it composer-setup.php

    . Use PHP to check the hash of the file you downloaded and compare it to the known value of the hash. You can always find the current value of the hash for the installer on the Composer Public Keys / Signatures page.
   
. Run the setup program to install composer. This does more than just download the latest copy of composer, it also sets up your local ~/.composer directory. This will install composer into the current directory. You can add the --install-dir=DIR to specify where you want composer installed. You can also specify --filename=composer to change the installed filename. You can use anything you like that doesn’t already exist in your specified directory, you don’t have to use the name composer. This is a great way to get rid of the .phar at the end of the name if you don’t like it.
   
. Use PHP to remove the installer from the current directory.

To install composer for PHP you use PHP to download the installer, set a few options, and then actually perform the install.

php -r "copy('https://getcomposer.org/installer', 'composer-setup.php');"

php -r "if (hash_file('SHA384', 'composer-setup.php') === '55d6ead61b29c7bdee5cccfb50076874187bd9f21f65d8991d46ec5cc90518f447387fb9f76ebae1fbbacf329e583e30') { echo 'Installer verified'; } else { echo 'Installer corrupt'; unlink('composer-setup.php'); } echo PHP_EOL;"

php composer-setup.php

php -r "unlink('composer-setup.php');"

Below is a version you can copy ‘n paste.

Breakdown:

Recommended Setup for Linux and macOS:

php -r "copy('https://getcomposer.org/installer', 'composer-setup.php');"

php -r "if (hash_file('SHA384', 'composer-setup.php') === '55d6ead61b29c7bdee5cccfb50076874187bd9f21f65d8991d46ec5cc90518f447387fb9f76ebae1fbbacf329e583e30') { echo 'Installer verified'; } else { echo 'Installer corrupt'; unlink('composer-setup.php'); } echo PHP_EOL;"

php composer-setup.php --install-dir=/usr/local/bin --filename=composer

php -r "unlink('composer-setup.php');"

WARNING: Line two IS WHERE IT compares the hasH of the installer you just downloaded to a hard-coded value. The value specified in the script is the value for the current version of the installer as of this writing. If it fails, check the Composer Public Keys / Signatures page and get the latest version. Plug it into the script below and try again.

Windows user, change the --installdir= to a directory in your path.

Recommended Setup for Windows

If you are running Microsoft Windows, the instructions above will work for you as long as you use the proper install paths. You can however download ComposerSetup.exe from the Composer Introduction page. Execute this and it will install composer and set your path so that you can run composer from anywhere. You will have to close your terminal window and open a new one after the install for the path to be updated.

That’s it, you should now have Composer installed.

Composer installation Resources

* Composer Homepage
* Composer Introduction
* Download Composer
* Composer Public Keys / Signatures

Unit testing is a crucial aspect of modern software development, ensuring that individual units of code function correctly in isolation. In PHP, unit testing helps developers identify bugs early in the development cycle, improve code quality, and facilitate code maintenance. In this comprehensive guide, we'll walk you through the process of creating unit tests in PHP, using popular testing frameworks like PHPUnit.

Why Unit Testing?

Unit testing involves testing individual components or units of code in isolation from the rest of the application. Here are some reasons why unit testing is essential:
   
. Bug Detection: Unit tests help identify bugs and regressions early in the development process, making them easier and cheaper to fix.
   
. Code Quality: Writing unit tests encourages developers to write modular, well-structured, and maintainable code.
   
. Improved Documentation: Unit tests serve as executable documentation, providing clear examples of how individual components of your code should behave.

Getting Started with PHPUnit:

PHPUnit is the most widely used testing framework for PHP. It provides a robust set of features for writing and executing unit tests. Let's dive into how you can get started with PHPUnit:

Installation:

You can install PHPUnit using Composer, the PHP package manager. Simply navigate to your project directory and run the following command:

composer require --dev phpunit/phpunit

This command installs PHPUnit as a development dependency in your project.

Writing Your First Test:

Now that PHPUnit is installed, let's create a simple test case. Create a new directory named tests in your project root, and within that directory, create a file named ExampleTest.php. Here's an example of what your test file might look like:

<?php

use PHPUnit\Framework\TestCase;

class ExampleTest extends TestCase
{
 public function testTrueAssertsToTrue()
 {
 $this->assertTrue(true);
 }
}

This test case contains a single test method named testTrueAssertsToTrue, which asserts that true is indeed true.

Running Tests:

To run your tests, simply execute PHPUnit from the command line, pointing it to your test directory. Run the following command in your project root:

vendor/bin/phpunit tests

PHPUnit will discover and execute all test cases within the specified directory, providing detailed feedback on the results.

Writing Testable Code:

Writing testable code is essential for effective unit testing. Here are some best practices to follow:
   
. Separation of Concerns: Ensure that your code follows the principle of separation of concerns, with clear boundaries between different components.
   
. Dependency Injection: Use dependency injection to inject dependencies into your classes, making it easier to replace them with mock objects during testing.
   
. Mocking and Stubbing: Use PHPUnit's mocking and stubbing features to simulate the behavior of dependencies and isolate the code under test.

Advanced Features:

PHPUnit provides a wide range of advanced features for writing comprehensive unit tests. Some notable features include:

-Data Providers: Use data providers to run a test method with multiple sets of data.

-Annotations: PHPUnit supports annotations for marking test methods, setting up fixtures, and configuring test execution.

-Code Coverage: PHPUnit can generate code coverage reports, showing which parts of your codebase are covered by your tests.

Conclusion:

Unit testing is an indispensable practice in modern PHP development, and PHPUnit makes it easy to write and execute unit tests for your codebase. In this guide, we've covered the basics of getting started with PHPUnit, writing testable code, and leveraging advanced features to write comprehensive unit tests. By incorporating unit testing into your development workflow, you can improve code quality, reduce bugs, and build more robust and maintainable PHP applications.

In the realm of web development, the Model-View-Controller (MVC) architectural pattern stands as one of the most influential paradigms. It provides a structured approach to designing web applications, promoting modularity, scalability, and maintainability. In this guide, we'll delve into the MVC framework in PHP, exploring its key components, principles, and benefits.

Understanding MVC Architecture:

MVC separates an application into three interconnected components, each with its distinct responsibility:

Model: The model represents the application's data and business logic. It encapsulates the data structure, database interactions, and validation rules. In MVC, the model is responsible for managing data persistence and state.

View: The view is responsible for presenting data to the user in a visually appealing format. It encompasses the HTML markup, CSS styling, and client-side scripting necessary to render the user interface. Views are typically passive components that receive data from the controller and display it to the user.

Controller: The controller acts as an intermediary between the model and the view. It processes user requests, invokes the appropriate methods in the model to retrieve or manipulate data, and selects the appropriate view to render the response. Controllers handle user input, orchestrate business logic, and coordinate the flow of data between the model and the view.

Implementing MVC Framework in PHP:

PHP offers a robust foundation for building MVC-based web applications. Let's explore how to implement each component of the MVC pattern in PHP:

Model:

In PHP, models typically represent data entities and interact with the database. They encapsulate data access logic and provide methods for querying, inserting, updating, and deleting records. Here's a simplified example of a model class:

class User { 
 public function getUserById($userId) { 
 } 

 public function updateUser($userId, $userData) { 
 }

}

View:

Views in PHP are responsible for generating HTML markup to render the user interface. They receive data from the controller and use it to dynamically generate the content displayed to the user. Views can include HTML templates with embedded PHP code or utilize template engines for better separation of concerns. Here's a basic example of a view:

<!DOCTYPE html>

<html>

<head> <title>User Profile</title>

</head>

<body> <h1>Welcome, <?php echo $user['username']; ?>!</h1> <p>Email: <?php echo $user['email']; ?></p>

</body>

</html>

Controller:

Controllers in PHP handle user requests, process input data, and interact with models to retrieve or manipulate data. They select the appropriate view to render the response and pass data to the view for presentation. Controllers are responsible for defining application routes and managing the overall application flow. Here's an example of a controller method:

class UserController { 
 public function profile($userId) { 
 $userModel = new User(); 
$userData = $userModel->getUserById($userId); 

include 'views/profile.php'; 
 }
}

Benefits of MVC Framework in PHP:

Separation of Concerns: MVC promotes a clear separation of concerns, making it easier to manage code complexity and maintainability.

Modularity: Components in MVC are modular and reusable, allowing developers to build and extend applications more efficiently.

Testability: With distinct components, it becomes easier to write unit tests for models, views, and controllers independently.

Scalability: MVC facilitates the scalability of web applications by enabling developers to add new features or modify existing ones without impacting other parts of the system.

Conclusion:

The MVC framework in PHP provides a robust architectural pattern for building scalable and maintainable web applications. By separating concerns into models, views, and controllers, developers can organize code more effectively, enhance testability, and streamline the development process. Whether you're building a simple blog or a complex enterprise application, leveraging the MVC pattern in PHP can significantly improve the quality and maintainability of your codebase.

In today's dynamic and fast-paced world of web development, ensuring the reliability, performance, and scalability of applications is paramount. Monitoring and observability tools play a crucial role in achieving these goals by providing insights into application metrics, performance trends, and system health. Prometheus, a popular open-source monitoring and alerting toolkit, offers robust capabilities for monitoring infrastructure and application metrics. In this article, we'll explore how to leverage Prometheus with PHP to monitor, analyze, and troubleshoot PHP-based applications effectively.

Understanding Prometheus:

Prometheus is an open-source monitoring and alerting system originally developed by SoundCloud. It is designed for reliability, scalability, and extensibility, making it suitable for monitoring complex, distributed systems. Key features of Prometheus include:

Time Series Data: Prometheus collects time-series data, allowing developers to track metrics such as CPU usage, memory consumption, request latency, and HTTP response codes over time.

PromQL: Prometheus Query Language (PromQL) enables users to query and aggregate metrics, create custom dashboards, and set up alerting rules based on specific conditions.

Scalability and Reliability: Prometheus is designed to be highly scalable and reliable, supporting a distributed architecture with multiple replicas and federated setups for global monitoring.

Integrating Prometheus with PHP:

To integrate Prometheus with PHP applications, developers can utilize client libraries and instrumentation libraries that facilitate metric collection and exposition. The following steps outline the process of integrating Prometheus with PHP:

Choose a Prometheus Client Library: Select a Prometheus client library for PHP that suits your needs. Popular options include prometheus/client_php and php-prometheus/client.

Instrument Your PHP Code: Instrument your PHP application code to collect relevant metrics. This involves adding instrumentation code to track metrics such as request duration, memory usage, database queries, and custom business metrics.

Exposing Metrics: Expose the collected metrics in a format compatible with Prometheus. This typically involves exposing an HTTP endpoint (e.g., /metrics) where Prometheus can scrape the metrics using the Prometheus exposition format.

Configure Prometheus Server: Configure the Prometheus server to scrape metrics from the PHP application's endpoint. Update the Prometheus configuration file (prometheus.yml) to include the target endpoint and define any additional scraping parameters.

Example Integration:

Let's illustrate how to integrate Prometheus with a PHP application using the prometheus/client_php library:

require 'vendor/autoload.php';

use Prometheus\CollectorRegistry;
use Prometheus\Storage\APC;
use Prometheus\RenderTextFormat;

$registry = new CollectorRegistry(new APC());

$requestDuration = $registry->registerCounter('php_requests_total', 'Total number of PHP requests');

$requestDuration->inc();

$renderer = new RenderTextFormat();
echo $renderer->render($registry->getMetricFamilySamples());

In this example, we register a custom metric (php_requests_total) to track the total number of PHP requests. We then increment this metric for each request and expose the metrics endpoint using the Prometheus exposition format.

Benefits of Using Prometheus with PHP:

Real-time Monitoring: Prometheus provides real-time monitoring capabilities, allowing developers to monitor application metrics and diagnose issues promptly.

Scalability: Prometheus scales horizontally, making it suitable for monitoring large-scale deployments and distributed systems.

Alerting: Prometheus supports alerting based on predefined rules, enabling proactive monitoring and alerting for potential issues or anomalies.

Integration: Prometheus integrates seamlessly with various programming languages, platforms, and frameworks, including PHP, enabling comprehensive monitoring across the entire technology stack.

Conclusion:

Prometheus offers powerful capabilities for monitoring and observability, making it a valuable tool for developers and DevOps teams tasked with ensuring the reliability and performance of PHP applications. By integrating Prometheus with PHP using client libraries and instrumentation, developers can gain valuable insights into application metrics, troubleshoot issues effectively, and proactively respond to performance anomalies. Embracing Prometheus as part of your monitoring strategy empowers organizations to build resilient, scalable, and high-performing PHP applications in today's dynamic digital landscape.