PHP Profiling – Performance Optimization Techniques

Performance optimization can measure the performance of our server-side scripts using several tools in different environments, especially Xdebug in development. In this article, we are going to concentrate on coding techniques, and use Xdebug to measure the performance of different scriptlets. We ran the codes several times and took the average execution time to create our benchmark. Let’s discuss a few coding styles and their impact on the performance.

With each major release of the language, the community provides considerable improvement in terms of speed.

Please note that PHP 7 is yet not recommended for the production environment, however, it claims to be much faster than its predecessors.

This can be a debate among several developers as to which one is faster. Usually, we all know that double quotes (“) checks for the presence of variables and adds a little bit of overhead in case of strict strings. But it’s not true for normal assignments, loops with fewer iterations or concatenation or interpolation of smaller bytes as it never shows any difference at all. We have tested using the following script.

However, you can observe noticeable difference for larger strings or huge iterations in loops where single quotes run faster than double quotes. This sort of micro-optimizations isn’t required but it’s still good practice to use single and double quotes sensibly wherever the need be, from a performance point of view.

Because the system tries to resolve the relative path to an absolute path before processing, we can save a step by providing an absolute path. Best practice includes defining and declaring a WEB_ROOT and then using it globally wherever required.

Unsetting large arrays, closing a file handler, closing a database connection or a curl request to any other server through an API are often overlooked by developers. As a result, more memory is occupied in maintaining the resources. We know that there is a garbage collector to do the tasks for us, but then we do not know when it will be called! It is always better to close a resource after it’s opened and our work is done. We can also use destructors in our classes because we know when the program controller exits a class. If a destructor is present, then it would automatically call the garbage collector.

Accessing a global variable is twice as costly as accessing a local variable, so if a global is declared and not used, or could have been declared as local, it adds up to a considerable amount of overhead.

For example: for ($x = 0; $x < count($array); $x++), in this statement the count function is called each time the loop iterates and it does the same thing over and over again. Instead if we declare a variable say $count = count($array); and then for ($x = 0; $x < $count; $x++), we can save processing time.

Instead of using count(), strlen(), sizeof(), it is better as well as safer to use isset() to compare the value returned with a specific number. Suppose we have a condition like (strlen($foo) < 50) we can do it like (!isset($foo{50})) and see the performance change.

Static methods/properties are generally faster than non-static ones. However, if an object is pre-initialized and then a non-static method/property is called repeatedly on the same object, non-static is faster.

Non-static methods skip a step of object initialization making them faster by 20% on average.

With an exception of PHP5.3 where nonstatic methods are faster, but that was due to the bug that was present in PHP 5.3 when they introduced late static bindings. The bug was fixed in later versions of PHP.

According to our benchmarks, the foreach loop is much faster than the for loop, and the for loop is faster than the while loop.

This is again a widely-debated topic. It behaves differently in different languages and depends on the environment. Post-incrementation in PHP has been documented as storing a temporary variable which attributes to this 10% overhead vs. pre-incrementation.

++$i is pre-incrementation, $i is incremented and the new value is returned.

$i++ is post-incrementation, the value of $i copied to an internal temporary variable, $i is incremented and the internal copy of the old value of $i is returned.

The difference measured by us is not much, so it's being recommended in this case to use it according to the need without worrying about the microscopic difference.

Echo is a language construct whereas print is a function, so without testing we can say echo is faster than print, most of the developers we have seen use echo overprint. This should not be a cause of worry, however, we have noted a considerable difference when strings are concatenated using a comma and not the period operator.

For example: echo $a, $b, $c; is faster than echo $a . $b . $c;, but echo $a . $b . $c; is faster than print $a . $b . $c.

Like C/C++, in PHP, we have printf and sprintf functions, which are least used in PHP scripts. Let us see one such example where we can use them.

Using sprintf is 10 times faster than using variables within double quotes in string formatting. There is a small difference between sprintf and printf: printf outputs the string, whereas sprintf stores the string in a variable.

The equality operator == typecasts, or converts the data type temporarily to see if it’s equal to the other operand whereas === (identity operator) doesn’t need to do any converting whatsoever and thus, it does less work, making it comparatively fast.

And hey, if you're a PHP developer looking for somewhere that appreciates clean, elegant, well-written code, why not apply for a job at CodeClouds? We're a global development company who offer our staff very competitive benefits and our Indian offices currently have PHP developer jobs in Kolkata available!