53 tips for improving PHP Performance

PHP tips Summary: 53 tips for improving PHP Performance
Use single quotes instead of double quotes to include strings, which is faster. Because PHP searches for variables in strings enclosed by double quotes,
Note: Only ECHO can do this. It is a function that can treat multiple strings as parameters:
In the PHP manual, ECHO is a language structure rather than a real function. Therefore, double quotation marks are added to the function ).
1. If the class method can be defined as static, it should be defined as static as much as possible, and its speed will be increased by nearly four times.
2. $ row ['id] 'is 7 times faster than $ row [ID.
3. Echo is faster than print, and multiple echo parameters are used to replace string connection,
For example, Echo $ str1 and $ str2.
4. determine the maximum number of cycles before executing the for loop. Do not calculate the maximum value for each loop. Use foreach instead.
5. Cancel unnecessary variables, especially large arrays, to release the memory.
6. Avoid using _ Get ,__ set ,__ autoload whenever possible.
7. require_once () is expensive.
8. When using include files, try to use absolute paths as much as possible, because it avoids PHP's file search speed in include_path,
It takes less time to parse the operating system path.
9. If you want to know the time when the script starts to be executed (the server receives the client request), use $ _ server ['request _ time']
Better than time ().
10. functions use the same functions instead of regular expressions.
11. The str_replace function is faster than the preg_replace function, but the strtr function is four times more efficient than the str_replace function.
12. If a string replacement function can take an array or character as a parameter and the parameter length is not too long, you can consider writing an additional one.
Segment replacement code, so that each passing parameter is a character, instead of writing only one line of code to accept arrays as the query and replacement parameters.
13. Using the select branch statement is better than using multiple if and else if statements.
14. Blocking error messages with @ is very inefficient and extremely inefficient.
15. Open the mod_deflate module of Apache to speed up web page browsing.
16. When the database connection is used up, it should be switched off. Do not use persistent connections.
17. The error message is expensive.
18. Increase the local variable in the method at the fastest speed. It is almost the same as calling a local variable in a function.
19. Increasing a global variable is twice slower than increasing a local variable.
20. Incrementing an object property (for example, $ this-> prop ++) is three times slower than incrementing a local variable.
21. Increasing an unspecified local variable is 9 to 10 times slower than increasing a predefined local variable.
22. Defining only one local variable without calling it in the function also slows down (to the extent that it is equivalent to increasing a local variable ). PHP will probably check whether
No. global variables exist.
23. Method calling seems to have nothing to do with the number of methods defined in the class, because I have added 10 methods before and after the test method, but the performance has not changed.
24. The methods in the derived class run faster than the same methods defined in the base class.
25. Calling an empty function with a parameter takes seven to eight times to increment local variables. Time spent on calling similar methods
The number of local variable increment operations is nearly 15 times.
26. Apache parses a PHP script two to ten times slower than parsing a static HTML page. Use static html pages and less scripts as much as possible.
27. Unless the script can be cached, it will be re-compiled every time it is called. Introducing a PHP cache mechanism can usually improve the performance by 25% to 100%, so as to avoid
In addition to the compilation overhead.
28. Use memcached as much as possible. Memcached is a high-performance memory object cache system that can accelerate dynamic web applications and reduce
Database load. It is useful for the cache of OP code, so that the script does not have to re-compile each request.
29. When operating a string and checking whether its length meets certain requirements, you will use the strlen () function. This function is executed quite fast,
Because it does not perform any calculations, it only returns the known String Length stored in the zval structure (C's built-in data structure, used to store PHP variables. However, because s
Trlen () is a function, which is more or less slow, because function calling goes through many steps, such as lowercase letters.
Name is case sensitive), hash search, will be executed along with the called function. In some cases, you can use the isset () technique to accelerate your code execution. (Example
For example)
If (strlen ($ Foo) <5) {echo 'foo is too short '} (compared with the following Technique)
If (! Isset ($ Foo {5}) {echo 'foo is too short '}
Calling isset () happens to be faster than strlen (), because, unlike the latter, isset () is a language structure, meaning that its execution does not require function searches and letters.
Lowercase. That is to say, in fact, you do not spend too much money in the top-level code that checks the string length.
34. When the execution variable $ I increments or decreases, $ I ++ is slower than ++ $ I. This difference is exclusive to PhP and does not apply to other languages, so do not modify
Your C or Java code and expect them to become faster immediately, useless. ++ $ I is faster because it only requires three commands (Opcodes), and $ I ++ requires four commands. Rear
Incremental actually generates a temporary variable, which is then incremented. The pre-increment directly increases on the original value. This is a kind of optimal processing, just
The PHP optimizer of Zend does that. Keeping in mind that this optimization processing is a good idea, because not all command optimizers perform the same optimization processing,
There are also a large number of Internet service providers (ISPs) and servers without command optimizers.
35. Object-oriented (OOP) is not required. Object-oriented usually has a high overhead, and each method and object call consumes a lot of memory.
36. arrays are also useful instead of using classes to implement all data structures.
37. Do not subdivide methods too much. Think carefully about the code you are actually planning to reuse.
38. when you need it, you can always break down the code into methods.
39. Try to use a large number of PHP built-in functions.
40. If there are a large number of time-consuming functions in the code, you can consider using C extension to implement them.
41. Profile your code. The validator will tell you how much time the Code consumes. The xdebug debugger contains an Inspection Program,
The evaluation test shows the code bottleneck in general.
42. mod_zip can be used as an Apache module to instantly compress your data and reduce the data transmission volume by 80%.
43. When file_get_contents can be used to replace file, fopen, feof, fgets, and other methods, use file_get_contents whenever possible, because
His efficiency is much higher! Note the PHP version of file_get_contents when opening a URL file;
44. Perform as few file operations as possible, although PHP file operations are not efficient;
45. Optimize select SQL statements and perform insert and update operations as little as possible (I have been maliciously approved in update );
46. Try to use PHP internal functions as much as possible (but in order to find a function that does not exist in PHP, I wasted time and experience writing a UDF.
Question !);
47. Do not declare variables inside the loop, especially big variables: Objects (Doesn't this seem to be a concern in PHP ?);
48. Do not use nested values for multi-dimensional arrays;
49. Do not use regular expressions when using internal PHP Strings To operate functions;
50. foreach is more efficient. Use foreach instead of the while and for loops;
51. Use single quotes instead of double quotes to reference strings;
52. Replace I = I + 1 with I + = 1. Meets the C/C ++ habits and is highly efficient.
53. For global variables, unset () should be used up;