Webramz blog

Here is the list of short tips you can use for writing an optimized and more efficient PHP code:

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, @import url(“css/widgContent.css”); INSERT:CONTENT:END SERVER['REQUEST_TIME'] is preferred to time()
10. See if you can use strncasecmp, strpbrk and stripos instead of regex
11. str_replace is faster than preg_replace, but strtr is faster than str_replace by a factor of 4
12. If the function, such as string replacement function, accepts both arrays and single characters as arguments, and if your argument list is not too long, consider writing a few redundant replacement statements, passing one character at a time, instead of one line of code that accepts arrays as search and replace arguments.
13. It’s better to use select statements than multi if, else if, statements.
14. Error suppression with @ is very slow.
15. Turn on apache’s mod_deflate
16. Close your database connections when you’re done with them
17. $row['id'] is 7 times faster than $row[id]
18. Error messages are expensive
19. Do not use functions inside of for loop, such as for ($x=0; $x < count($array); $x) The count() function gets called each time.
20. Incrementing a local variable in a method is the fastest. Nearly the same as calling a local variable in a function.
21. Incrementing a global variable is 2 times slow than a local var.
22. Incrementing an object property (eg. $this->prop++) is 3 times slower than a local variable.
23. Incrementing an undefined local variable is 9-10 times slower than a pre-initialized one.
24. Just declaring a global variable without using it in a function also slows things down (by about the same amount as incrementing a local var). PHP probably does a check to see if the global exists.
25. Method invocation appears to be independent of the number of methods defined in the class because I added 10 more methods to the test class (before and after the test method) with no change in performance.
26. Methods in derived classes run faster than ones defined in the base class.
27. A function call with one parameter and an empty function body takes about the same time as doing 7-8 $localvar++ operations. A similar method call is of course about 15 $localvar++ operations.
28. Surrounding your string by ‘ instead of ” will make things interpret a little faster since php looks for variables inside “…” but not inside ‘…’. Of course you can only do this when you don’t need to have variables in the string.
29. When echoing strings it’s faster to separate them by comma instead of dot. Note: This only works with echo, which is a function that can take several strings as arguments.
30. A PHP script will be served at least 2-10 times slower than a static HTML page by Apache. Try to use more static HTML pages and fewer scripts.
31. Your PHP scripts are recompiled every time unless the scripts are cached. Install a PHP caching product to typically increase performance by 25-100% by removing compile times.
32. Cache as much as possible. Use memcached – memcached is a high-performance memory object caching system intended to speed up dynamic web applications by alleviating database load. OP code caches are useful so that your script does not have to be compiled on every request
33. When working with strings and you need to check that the string is either of a certain length you’d understandably would want to use the strlen() function. This function is pretty quick since it’s operation does not perform any calculation but merely return the already known length of a string available in the zval structure (internal C struct used to store variables in PHP). However because strlen() is a function it is still somewhat slow because the function call requires several operations such as lowercase & hashtable lookup followed by the execution of said function. In some instance you can improve the speed of your code by using an isset() trick.Example:

    if (strlen($foo) < 5) { echo "Foo is too short"; }
vs.
if (!isset($foo{5})) { echo "Foo is too short"; } Calling isset() happens to be faster then strlen() because unlike strlen(), isset() is a language construct and not a function meaning that it’s execution does not require function lookups and lowercase. This means you have virtually no overhead on top of the actual code that determines the string’s length.

34. When incrementing or decrementing the value of the variable $i++ happens to be a tad slower then ++$i. This is something PHP specific and does not apply to other languages, so don’t go modifying your C or Java code thinking it’ll suddenly become faster, it won’t. ++$i happens to be faster in PHP because instead of 4 opcodes used for $i++ you only need 3. Post incrementation actually causes in the creation of a temporary var that is then incremented. While pre-incrementation increases the original value directly. This is one of the optimization that opcode optimized like Zend’s PHP optimizer. It is a still a good idea to keep in mind since not all opcode optimizers perform this optimization and there are plenty of ISPs and servers running without an opcode optimizer.
35. Not everything has to be OOP, often it is too much overhead, each method and object call consumes a lot of memory.
36. Do not implement every data structure as a class, arrays are useful, too
37. Don’t split methods too much, think, which code you will really re-use
38. You can always split the code of a method later, when needed
39. Make use of the countless predefined functions
40. If you have very time consuming functions in your code, consider writing them as C extensions
41. Profile your code. A profiler shows you, which parts of your code consumes how many time. The Xdebug debugger already contains a profiler. Profiling shows you the bottlenecks in overview
42. mod_gzip which is available as an Apache module compresses your data on the fly and can reduce the data to transfer up to 80%
43. Excellent Article about optimizing php by John Lim

As Chris Hartjes points out there’s a new release of the popular PHP framework CakePHP (as well as a new web site design).

You can grab the latest download directly from the homepage or look into the manual to find out more about the framework and how it can be used.

If your host allows you to, you can use a custom php.ini file within your Linux shared hosting environment. By utilizing .htaccess you are able to create a custom fileset which you can then use to disable and enable PHP functions as per your wish within your website; this can be done site-wide or directory-wide. This can be helpful to you if your host has disabled certain modules within the server wide php.ini file, or if there are modules which are enables but you’d rather have disabled, for example if they don’t work with a PHP application which you have installed on your website. As long as you are able to within your shared hosting environment, the deployment of a custom php.ini file is relatively easy if the following steps are followed.

Deploying a Custom PHP.ini File

First off, you need to create a .htaccess file; you might already have one within your hosting environment, if so you can easily edit. In either case, you will need to add the following line to the .htaccess to enable Apache to find the custom php.ini file:

SetEnv PHPRC /path/to/custom/php.ini

You will then need to create the custom php.ini file itself within your site – the file can actually be named anything and can have any posess any extension, if you want it to. Within this file you are able to specify whether PHP modules are enabled or disabled for your website – Apache will pick the custom php.ini file up via the use of your .htaccess file and will then apply your custom settings to your virtual environment on run time. For our example we will be disabling PHP’s use of magic quotes. To disable PHP’s use of magic quotes on run time, we will need to paste the following three lines into our custom PHP.ini file:

magic_quotes_gpc = Off
magic_quotes_runtime = Off
magic_quotes_sybase = Off

Once that has been done, as long as the .htaccess file is pointed towards the correct custom php.ini file, Apache should pick the changes up on the next run and the specified modules or settings will take effect every time your site is run as long as the appropriate files are in their correct locations. By doing this, you are able to ensure that all custom settings for your website are served on the next run, meaning that they will always be applied to it. Another example of a module being changed would be the setting of the time zone for your website through the use of a custom php.ini file, to do this we need to paste the following code into the file:

date.timezone = “America/Indianapolis”

The example shown sets the date timezone to Indiana, America; if we want to set our time zone of GMT London, we need to paste in the following code:

date.timezone = “Europe/London”

Changing the time zone can be an important change, since your website might be hosted in somewhere like America, but your audience however might be Australia – that is a vast time difference. Some applications are time/date sensitive, which means that you should ensure that you change the time zone to fit in with your audience, as it could cause confusion with both the system and your visitors if a different time from what they’re use to is displayed, or if completely the wrong day is set.

Conclusion

With the use of .htaccess you are able to use a custom php.ini at either site or directory levels within yoru website, allowing you to run your website with the appropriate settings as per your wish. This is good since it allows you to achieve things which in some cases are only achievable within a dedicated environment such as a VPS server or a dedicated server. Also, some applications only work if certain PHP settings are enabled or disabled, so this allows you to customize your environment to ensure you are able to run any type of PHP application. This sort of tweaking is something that certainly allows you to make the best out of your shared or reseller website hosting.