PHP Optimization Tips

Question

I'm looking for PHP Optimization tips. Coding practices and other methodologies which will make my PHP execute faster. One tip per answer, please, and include why it makes the code faster!

This is not about HTML or Javascript execution, but purely server side PHP execution.

Answer 1

I enclose strings that doesn't contain variables with single quotes. This tells the compiler that it doesn't need to search for variables to replace.

echo 'This string is faster';
echo "This string is slower";

Answer 2

prefer require and include over thier _once counterparts

EDIT: added at request of commenter: because require_once requires checks to see if the file has been included before. Benchmark it yourself and you'll see its noticeably slower.

Answer 3

There are dozens of small performance tweaks; For example:

$text = 'test'; is faster as $text = "test"; (because the double quote's parse variables) BUT: $text = "testing: $text"; is faster as $text = 'testing: ' . $text;

Answer 4

use array_key_exists() to find values in arrays rather than in_array()

Answer 5

the mysql extension is faster than the mysqli extention, which is (sometimes) faster than PDO.

If you use mysqli in conjunction with mysqlnd thats faster still

Answer 6

Focus on optimising your database querying rather than your php, really.

Answer 7

40 Tips for optimizing your PHP code:

http://reinholdweber.com/?p=3

Here's a few from the list:

1. If a method can be static, declare it static. Speed improvement is by a factor of 4.
2. echo is faster than print.
3. Use echo's multiple parameters instead of string concatenation.
4. Set the maxvalue for your for-loops before and not in the loop.
5. Unset your variables to free memory, especially large arrays.
6. Avoid magic like __get, __set, __autoload
7. require_once() is expensive
8. Use full paths in includes and requires, less time spent on resolving the OS paths.
9. If you need to find out the time when the script started executing, $_SERVER[’REQUEST_TIME’] is preferred to time()

10. See if you can use strncasecmp, strpbrk and stripos instead of regex

    ...[snip]...

Answer 8

Use a cached length value when iterating over arrays - this works across other languages too, and can give you significant speed gains if the set of elements you are iterating over is large or if the size calculation is complex.

$length = count($some_array)

for ($count = 0; $count < $length; $count++) {
  ...
}

Answer 9

foreach is faster than while(list()=each()) when you're not modifying values, if you're modifying the hash, while(list()=each()) is faster

Answer 10

Use late-binding, that is only including specific files/classes when they are needed. Less code to parse.

Answer 11

I realise this doesn't answer the question - but I happen to think its worth saying.

Nearly all of these 'optimizations' are premature, and should probably not be implemented at the expense of making code easy to understand and maintain. There are likley to me much larger bottlenecks than these optimizations.

Answer 12

If this is for a static environment, such as a web server module or using FastCGI, use an opcode cache. That way, each file is only compiled once (or whenever it is updated on disk). APC is a popular open source opcode cache and is scheduled to be included in PHP6.

Answer 13

If you really need to optimise "the PHP" code then using a "PHP accelerator" is probably the best bang for your buck - it basically just caches the compiled bytecode of scripts so this operation doesn't have to be done repeatedly. Useful for OOP with lots of different files, etc.

Answer 14

Reduce the number of operations within loops whenever possible.

Here's a pointless-but-illustrative example.

<?php
$data = array(
     'Santa Claus'
    , 'Clark Kent'
    , 'Barack Obama'
);

$displayAsUpperCase = true;

foreach ( $data as $datum )
{
    if ( $displayAsUpperCase )
    {
     echo strtoupper( $datum ), "\n";
    } else {
     echo $datum, "\n";
    }
}

See how the condition is executed every iteration? This is unnecessary, since the $displayAsUpperCase flag never changes during the lifetime of the loop. The solution is to use the value of the flag to define a callback

<?php
$data = array(
     'Santa Claus'
    , 'Clark Kent'
    , 'Barack Obama'
);

$displayAsUpperCase = true;

$displayCallback = ( $displayAsUpperCase ) ? 'strtoupper' : create_function( '$data', 'return $data;' );

foreach ( $data as $datum )
{
    echo call_user_func( $displayCallback, $datum ), "\n";
}

For those of you taking notes, this is a similar strategical process to polymorphism.

Answer 15

use the string handling functions instead of preg_ and ereg_ functions if you can.

Answer 16

Performance is sooooo overrated. Lots of programmers tend to overoptimise their code for speed forgetting that in most cases they:

1. Make the program more obscure
2. Introduce potential flaws
3. Increase codebase that needs to be maintained

All these factors significantly raise the overall development cost. Why not focus on lowering cost instead of chasing another 10µs optimisation? What is the single biggest share in software development cost? Is it server? Network throughput? CPU cycles? RAM or disk space? Nope. It's the programmer. You cost big bucks!

Write your programs so they are optimised for humans, not computers. It is much faster for you to create a Decorator and waste some CPU power than trying to inject if-conditions to whole inheritance tree and then wasting another hour scratching your head what the hell went wrong.

Computers should work hard. For you it is better to work smart.

Answer 17

There are several ways to improve performance including:

• Use a php accelerator.
• Make use of Caching.
• Best of all, use a profiler to actually pin-point your performance issues. Nothing is worse then to solve problems that aren't there.

I would advice reading http://developer.yahoo.com/performance/rules.html not php specific but very usefull.

Answer 18

Use an opcode cache: http://php.net/apc

Answer 19

Opcode cache's such as eAccelerator I've always found have made a significant improvement to the performance of many applications.

Answer 20

To sum things up...

1. Don't worry about optimization until you actually run into a bottleneck. Premature optimization will just introduce bugs and make the code harder to maintain.
2. Use a PHP Opcache such as APC, xCache or Turck MMCache, or a memory caching system such as memcached.

The following is a list of "optimizations" you can use in your code, but the differences are so minuscule, you shouldn't use these at the expense of unreadable, unmanageable code.

1. Use require and include instead of require_once and include_once, which are slower.
2. echo is faster than print
3. $_SERVER['REQUEST_TIME'] is faster than time(), which invokes a system call (php5)
4. Calculate the limit for a for loop before the loop, not in the loop condition.
5. Only inlcuded code/files/classes that are actually needed.
6. Enclose literal strings in single quotes unless they actually contain variables you want to evaluate and insert into the string.
7. Type-specific comparison operators are faster then non-type specific ones, when you know the types of the variables you are comparing. $x === 5 is faster than $x == 5, but will evaluate to false if $x is the string '5' for example.
8. Use string functions instead of regular expressions where appropriate. To find if a string is contained in another string use strpos or stripos. To replace values in a string when you don't need regular expressions, use str_replace.
9. preg_* functions are faster than ereg_* regular expression functions.
10. Do as little as possible inside loops, especially avoid many if constructs when possible.
11. Free memory with unset, when a variable is no longer needed.
12. Using full paths for includes and requires is faster than relative paths.
13. Avoid "magic" functions when possible. __autoload, __call etc.
14. Sending multiple parameters to echo (separated by a comma) is faster than string concatenation.

You also have to correctly optimize your database schema and queries.

1. Make sure you denormalize your database in key areas where appropriate.
2. Make sure you have indices where needed.
3. Make sure you don't have unneeded indices.
4. Optimize your queries. For example an IN() sub-query is many,many times slower than an INNER JOIN sub-query.

Answer 21

Basic optimalisation philosophy is: Having to do less, but with the same end result.

Havin said that, performance issues are almost always I/O bound (SQL, etc), So focus on that, instead of optimizing for CPU and memory.

If speed is important you should consider building a profiler in your scripts This profiler can be used to see which pages / queries are slow. Basic example of a profiler:

... in query function ....
global $query_log;
$start = microtime(true);
mysql_query($sql);
$query_execution_time = microtime(true) - $start;
$query_log[$sql] = query_execution_time;

... end of script ....
var_dump($query_log);

If your php system is using classes I can recommend looking into the "__autoload" / "spl_autoload_register" function. This mechanism can reduce your code. (less include/require lines) and speed up your code because class files will only be loaded when they are used.

Answer 22

If you want a side-by-side comparison of different PHP language features, check out PHP Benchmark. It actually runs comparison tests each time the page is loaded. If you search, there are other sites like it as well.

Answer 23

Some of the above tips look very similar to what Google has published some time ago:

Google Optimization Tips

A lot of the advice (like echo vs print, single vs double quotes, etc.) have been actually contradicted by the PHP team themselves:

PHP optimization advice clarified

and here is another article with some numbers:

Debunking Google’s Internet Optimization Tips

Answer 24

You really need to check this site out : The PHP Benchmark.

The code examples on the site are automatically generated and run when you enter the site and the benchmark is added to the global statistics.

Really cool.