有哪些好的 PHP 性能技巧？

What are some good PHP performance tips?

提问by timw4mail

I've heard of some performance tips for PHP such as using strtr()over str_replace()over preg_replace()depending on the situation.

我听说过一些 PHP 的性能技巧，例如根据情况使用strtr()over str_replace()over preg_replace()。

As far as using certain functions over others, and code style, what are some of the performance tips that you know of?

至于使用某些功能而不是其他功能和代码风格，您知道哪些性能提示？

Edit: I'm not talking about use of things that make code less readable, like !isset($foo{5})over strlen($foo) < 5, I'm talking about things like using preg_ functions over ereg_ functions for regex.

编辑：我不是在谈论使用使代码可读性降低的东西，比如!isset($foo{5})over strlen($foo) < 5，我在谈论使用 preg_ 函数而不是 ereg_ 函数的正则表达式。

Edit: The reason I ask this is not for nitpicking over when to optimize, but to get a general idea of what tends to be most efficient in a limited set of alternatives. For instance, checking if a mysql statement returned an error is arguably better practice than suppressing the errors to begin with.

编辑：我问这个的原因不是为了挑剔什么时候优化，而是为了大致了解在一组有限的替代方案中什么往往是最有效的。例如，检查 mysql 语句是否返回错误可以说是比抑制错误更好的做法。

回答by Vincent Savard

This question is really vague. When you want to optimize your script, you first check your database and try to optimize your algorithms. There aren't many pure PHP performance tips that are going to matter. Let's see :

这个问题真的很模糊。当你想优化你的脚本时，你首先检查你的数据库并尝试优化你的算法。没有多少纯粹的 PHP 性能技巧会很重要。让我们来看看 ：

• Concatening variables is faster than just putting them in a double-quotation mark string.

  $var = 'Hello ' . $world; // is faster than
  $var = "Hello $world"; // or
  $var = "Hello {$world}";
  

• 连接变量比将它们放在双引号字符串中要快。

  $var = 'Hello ' . $world; // is faster than
  $var = "Hello $world"; // or
  $var = "Hello {$world}";
  

Yes, it's faster, but the second and third form are even more readable and the loss of speed is so low it doesn't even matter.

是的，它更快，但第二和第三种形式更具可读性，速度损失如此之低，甚至无关紧要。

• When using a loop, if your condition uses a constant, put it before the loop. For instance :

  for ($i = 0; $i < count($my_array); $i++)
  

• 使用循环时，如果条件使用常量，请将其放在循环之前。例如 ：

  for ($i = 0; $i < count($my_array); $i++)
  

This will evaluate count($my_array) every time. Just make an extra variable before the loop, or even inside :

这将每次评估 count($my_array) 。只需在循环之前或什至在内部创建一个额外的变量：

for ($i = 0, $count = count($my_array); $i < $count; $i++)

• The worst thing is definitely queries inside loops. Either because of lack of knowledge (trying to simulate a JOIN in PHP) or just because you don't think about it (many insert into in a loop for instance).

  $query = mysql_query("SELECT id FROM your_table");
  while ($row = mysql_fetch_assoc($query)) {
      $query2 = mysql_query("SELECT * FROM your_other_table WHERE id = {$row['id']}");
      // etc
  }
  

• 最糟糕的事情肯定是在循环内查询。要么是因为缺乏知识（尝试在 PHP 中模拟 JOIN），要么只是因为您没有考虑它（例如，许多插入到循环中）。

  $query = mysql_query("SELECT id FROM your_table");
  while ($row = mysql_fetch_assoc($query)) {
      $query2 = mysql_query("SELECT * FROM your_other_table WHERE id = {$row['id']}");
      // etc
  }
  

Neverdo this. That's a simple INNER JOIN.

永远不要这样做。这是一个简单的 INNER JOIN。

There are probably more, but really, it's not worth writing all of them down. Write your code, optimize later.

可能还有更多，但实际上，不值得全部写下来。编写代码，稍后优化。

P.S. I started writing this answer when there was none, there may be some things already said in links.

PS我在没有答案时开始写这个答案，链接中可能已经说过一些事情。

Edit: for some reason, I can't format the code correctly. I really don't understand why.

编辑：出于某种原因，我无法正确格式化代码。我真的不明白为什么。

回答by alcuadrado

PREMATURE OPTIMIZATION IS THE ROOT OF ALL EVIL

过早优化是万恶之源

And that's the most important tip you need. If some day you have a real performance problem, profile your application, detect the compromised areas, and came here to ask again :)

这是您需要的最重要的提示。如果有一天您遇到真正的性能问题，请分析您的应用程序，检测受损区域，然后再次来这里询问:)

回答by Rohan Khude

66 Tips for optimizing your PHP

优化 PHP 的 66 个技巧

Here are Webber's points:

以下是韦伯的观点：

• Use JSON Instead of XML.
• Can also use sprintf instead of variables contained in double quotes, it's about 10x faster.
• Avoid the PHP mail() function header injection issue.
• If a method can be static, declare it static. Speed improvement is by a factor of 4.
• echo is faster than print.(* compare with list from phplens by John Lim)
• Use echo's multiple parameters instead of string concatenation.
• Set the maxvalue for your for-loops before and not in the loop.
• Unset your variables to free memory, especially large arrays.
• Avoid magic like __get, __set, __autoload
• require_once() is expensive
• Use full paths in includes and requires, less time spent on resolving the OS paths.
• If you need to find out the time when the script started executing, $_SERVER['REQUEST_TIME'] is preferred to time()
• See if you can use strncasecmp, strpbrk and stripos instead of regex
• str_replace is faster than preg_replace, but strtr is faster than str_replace by a factor of 4
• 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.
• It's better to use select statements than multi if, else if, statements.
• Error suppression with @ is very slow.
• Turn on apache's mod_deflate
• Close your database connections when you're done with them
• $row['id'] is 7 times faster than $row[id]
• Error messages are expensive
• Do not use functions inside of for loop, such as for ($x=0; $x < count($array); $x) The count() function gets called each time.
• Incrementing a local variable in a method is the fastest. Nearly the same as calling a local variable in a function.
• Incrementing a global variable is 2 times slow than a local var.
• Incrementing an object property (eg. $this->prop++) is 3 times slower than a local variable.
• Incrementing an undefined local variable is 9-10 times slower than a pre-initialized one.
• 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.
• 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.
• Methods in derived classes run faster than ones defined in the base class.
• 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.
• 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.
• 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.
• 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.
• 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.
• 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
• 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.
  Ex.
  view sourceprint?1.if (strlen($foo) < 5) { echo "Foo is too short"; }

  vs.

  view sourceprint?1.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.

• 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.
• Not everything has to be OOP, often it is too much overhead, each method and object call consumes a lot of memory.
• Do not implement every data structure as a class, arrays are useful, too
• Don't split methods too much, think, which code you will really re-use
• You can always split the code of a method later, when needed
• Make use of the countless predefined functions
• If you have very time consuming functions in your code, consider writing them as C extensions
• 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
• 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%
• Excellent Article about optimizing php by John Lim

• 使用 JSON 而不是 XML。
• 也可以使用 sprintf 而不是包含在双引号中的变量，它大约快 10 倍。
• 避免 PHP mail() 函数头注入问题。
• 如果方法可以是静态的，则将其声明为静态。速度提高了 4 倍。
• echo 比打印快。（* 与 John Lim 的 phplens 列表进行比较）
• 使用 echo 的多个参数而不是字符串连接。
• 在循环之前而不是在循环中设置 for 循环的最大值。
• 取消设置变量以释放内存，尤其是大型数组。
• 避免像 __get, __set, __autoload 这样的魔法
• require_once() 很昂贵
• 在包含和需要中使用完整路径，减少解析操作系统路径所花费的时间。
• 如果你需要找出脚本开始执行的时间， $_SERVER['REQUEST_TIME'] 比 time() 更受欢迎
• 看看是否可以使用 strncasecmp、strpbrk 和 stripos 代替正则表达式
• str_replace 比 preg_replace 快，但 strtr 比 str_replace 快 4 倍
• 如果函数，比如字符串替换函数，既接受数组也接受单个字符作为参数，并且如果你的参数列表不是太长，考虑写一些冗余的替换语句，一次传递一个字符，而不是一行代码接受数组作为搜索和替换参数。
• 使用 select 语句比使用 multi if, else if, 语句更好。
• 用@ 抑制错误很慢。
• 开启apache的mod_deflate
• 完成后关闭数据库连接
• $row['id'] 比 $row[id] 快 7 倍
• 错误消息代价高昂
• 不要在 for 循环内部使用函数，例如 for ($x=0; $x < count($array); $x) count() 函数每次都会被调用。
• 在方法中递增局部变量是最快的。几乎与在函数中调用局部变量相同。
• 增加全局变量比局部变量慢 2 倍。
• 递增对象属性（例如 $this->prop++）比局部变量慢 3 倍。
• 增加未定义的局部变量比预初始化的慢 9-10 倍。
• 仅仅声明一个全局变量而不在函数中使用它也会减慢速度（与增加局部变量大致相同）。PHP 可能会检查全局是否存在。
• 方法调用似乎与类中定义的方法数量无关，因为我向测试类（在测试方法之前和之后）添加了 10 个以上的方法，而性能没有变化。
• 派生类中的方法比基类中定义的方法运行得更快。
• 带有一个参数和一个空函数体的函数调用与执行 7-8 个 $localvar++ 操作所需的时间大致相同。一个类似的方法调用当然是大约 15 个 $localvar++ 操作。
• 用 ' 而不是 ” 包围你的字符串会使事情解释得更快一点，因为 php 在“...”中查找变量，而不是在 '...' 中。当然，只有在字符串中不需要变量时才可以这样做。
• 当回显字符串时，用逗号而不是点分隔它们会更快。注意：这仅适用于 echo，这是一个可以将多个字符串作为参数的函数。
• Apache 提供 PHP 脚本的速度至少比静态 HTML 页面慢 2-10 倍。尝试使用更多的静态 HTML 页面和更少的脚本。
• 除非脚本被缓存，否则每次都会重新编译您的 PHP 脚本。安装 PHP 缓存产品通常可以通过消除编译时间将性能提高 25-100%。
• 尽可能缓存。使用 memcached – memcached 是一种高性能内存对象缓存系统，旨在通过减轻数据库负载来加速动态 Web 应用程序。OP 代码缓存很有用，因此您的脚本不必针对每个请求都进行编译
• 在处理字符串时，您需要检查字符串是否具有特定长度，您可以理解地希望使用 strlen() 函数。此函数非常快，因为它的操作不执行任何计算，而仅返回 zval 结构（用于在 PHP 中存储变量的内部 C 结构）中可用字符串的已知长度。然而，因为 strlen() 是一个函数，它仍然有点慢，因为函数调用需要几个操作，例如小写和哈希表查找，然后执行所述函数。在某些情况下，您可以使用 isset() 技巧来提高代码速度。
  前任。
  查看 sourceprint?1.if (strlen($foo) < 5) { echo "Foo is too short"; }

  对比

  查看 sourceprint?1.if (!isset($foo{5})) { echo "Foo is too short"; }

  调用 isset() 恰好比 strlen() 更快，因为与 strlen() 不同，isset() 是一种语言结构而不是函数，这意味着它的执行不需要函数查找和小写字母。这意味着在确定字符串长度的实际代码之上几乎没有开销。

• 当增加或减少变量 $i++ 的值时，恰好比 ++$i 慢一点。这是 PHP 特有的，不适用于其他语言，所以不要去修改你的 C 或 Java 代码，认为它会突然变得更快，它不会。++$i 恰好在 PHP 中更快，因为 $i++ 使用的操作码不是 4 个，您只需要 3 个。后增量实际上会导致创建一个临时变量，然后增量。而预增量直接增加原始值。这是像 Zend 的 PHP 优化器一样优化 opcode 的优化之一。记住这仍然是一个好主意，因为并非所有操作码优化器都执行此优化，并且有大量 ISP 和服务器在没有操作码优化器的情况下运行。
• 不是所有的东西都必须是OOP，往往开销太大，每个方法和对象调用都会消耗大量内存。
• 不要将每个数据结构都实现为一个类，数组也很有用
• 不要把方法拆分太多，想想，你会真正重用哪些代码
• 您可以随时在需要时拆分方法的代码
• 使用无数的预定义功能
• 如果您的代码中有非常耗时的函数，请考虑将它们编写为 C 扩展
• 分析您的代码。分析器会向您显示代码的哪些部分消耗了多少时间。Xdebug 调试器已经包含一个分析器。分析向您展示了总体瓶颈
• mod_gzip 可用作 Apache 模块，可即时压缩您的数据，并可将传输的数据减少多达 80%
• John Lim 关于优化 php 的优秀文章

As Reihold Webber pointed to a post from John Lim (found this article copied without state the source here), then i investigate further and truly that is an excellent best practice tutorial for optimizing the php code performance, covered almost all aspects from low level webserver configuration, PHP configuration, coding styling, and performace comparisson as well.

正如 Reihold Webber 指出 John Lim 的一篇文章（发现这篇文章是在没有说明来源的情况下复制的），然后我进一步研究了这是一个优化 php 代码性能的优秀最佳实践教程，几乎涵盖了低级网络服务器的所有方面配置、PHP 配置、编码样式和性能比较。

Another good practice for better php performance as written in cluesheet.com are:

另一个更好的 php 性能的好习惯写在线索表.com 是：

• Do use single quotes over double quotes.
• Do use switch over lots of if statements
• Do avoid testing loop conditionals with function tests every iteration eg. for($i=0;i<=count($x);$i++){…
• Do use foreach for looping collections/arrays. PHP4 items are byval, greater than PHP5 items are byref
• Do consider using the Singleton Method when creating complex PHP classes.
• Do use POST over GET for all values that will wind up in the database for TCP/IP packet performance reasons.
• Do use ctype_alnum,ctype_alpha and ctype_digit over regular expression to test form value types for performance reasons.
• Do use full file paths in production environment over basename/fileexists/open_basedir to avoid performance hits for the filesystem having to hunt through the file path. Once determined, serialize and/or cache path values in a $_SETTINGS array. $_SETTINGS["cwd"]=cwd(./);
• Do use require/include over require_once/include_once to ensure proper opcode caching.
• Do use tmpfile or tempnam for creating temp files/filenames
• Do use a proxy to access web services (XML or JSOM) on foreign domains using XMLHTTP to avoid cross-domain errors. eg. foo.com<–>XMLHTTP<–>bar.com
• Do use error_reporting (E_ALL); during debug.
• Do set Apache allowoverride to “none” to improve Apache performance in accessing files/directories.
• Do use a fast fileserver for serving static content (thttpd). static.mydomain.com, dynamic.mydomain.com
• Do serialize application settings like paths into an associative array and cache or serialize that array after first execution.
• Do use PHP output control buffering for page caching of heavilty accessed pages
• Do use PDO prepare over native db prepare for statements. mysql_attr_direct_query=>1
• Do NOT use SQL wildcard select. eg. SELECT *
• Do use database logic (queries, joins, views, procedures) over loopy PHP.
• Do use shortcut syntax for SQL insers if not using PDO parameters parameters. eg. INSERT INTO MYTABLE (FIELD1,FIELD2) VALUES ((“x”,”y”),(“p”,”q”));

• 在双引号上使用单引号。
• 使用 switch 切换大量 if 语句
• 避免在每次迭代中使用函数测试来测试循环条件，例如。for($i=0;i<=count($x);$i++){…
• 使用 foreach 循环集合/数组。PHP4项为byval，大于PHP5项为byref
• 在创建复杂的 PHP 类时，请考虑使用单例方法。
• 对于所有将因 TCP/IP 数据包性能原因出现在数据库中的值，请使用 POST over GET。
• 出于性能原因，请在正则表达式上使用 ctype_alnum、ctype_alpha 和 ctype_digit 来测试表单值类型。
• 请在生产环境中通过 basename/fileexists/open_basedir 使用完整的文件路径，以避免文件系统必须搜索文件路径而导致性能下降。一旦确定，序列化和/或缓存 $_SETTINGS 数组中的路径值。$_SETTINGS["cwd"]=cwd(./);
• 在 require_once/include_once 上使用 require/include 以确保正确的操作码缓存。
• 使用 tmpfile 或 tempnam 创建临时文件/文件名
• 请使用代理访问使用 XMLHTTP 的外部域上的 Web 服务（XML 或 JSOM）以避免跨域错误。例如。foo.com<–>XMLHTTP<–>bar.com
• 使用 error_reporting (E_ALL); 调试期间。
• 请将 Apache allowoverride 设置为“none”以提高 Apache 访问文件/目录的性能。
• 请使用快速文件服务器来提供静态内容 (thttpd)。static.mydomain.com、dynamic.mydomain.com
• 将应用程序设置（如路径）序列化为关联数组，并在第一次执行后缓存或序列化该数组。
• 一定要使用 PHP 输出控制缓冲来缓存大量访问的页面
• 使用 PDO prepare 代替原生 db prepare for 语句。mysql_attr_direct_query=>1
• 不要使用 SQL 通配符选择。例如。选择 *
• 不要在循环的 PHP 上使用数据库逻辑（查询、连接、视图、过程）。
• 如果不使用 PDO 参数参数，请对 SQL 插入器使用快捷语法。例如。INSERT INTO MYTABLE (FIELD1,FIELD2) VALUES (("x","y"),("p","q"));

Ref - gist.github.com

参考 - gist.github.com

I visited other blogs and compared all the above points and tried to add everything here for optimising your PHP code.

我访问了其他博客并比较了上述所有要点，并尝试在此处添加所有内容以优化您的 PHP 代码。

Hope this helps you.

希望这对你有帮助。

回答by Webnet

If you're looking for good tips on how to program your code so that it's the most efficient, refer to http://www.phpbench.com/. They show a lot of comparisons on various aspects of programming so you can utilize the best methods that fit your needs. Generally it comes down to whether you're looking to save on processing power or memory usage.

如果您正在寻找有关如何编写代码以使其最高效的好技巧，请参阅http://www.phpbench.com/。它们对编程的各个方面进行了大量比较，因此您可以利用适合您需求的最佳方法。通常，这取决于您是否希望节省处理能力或内存使用量。

http://talks.php.net/show/digg/0- A talk given by PHP themselves on performance

http://talks.php.net/show/digg/0- PHP 自己关于性能的演讲

http://code.google.com/speed/articles/optimizing-php.html- Recommendations by Google on how to speed up your applications

http://code.google.com/speed/articles/optimizing-php.html- Google 关于如何加速应用程序的建议

Most commonly your problems aren't with PHP, but are going to be MySQL or http requests issues.

最常见的问题不是 PHP，而是 MySQL 或 http 请求问题。

回答by jgmjgm

This one might seem a bit extreme but...

这个可能看起来有点极端，但是......

PHP is extremely slow. This is undeniable. It is one of the slowest languages out there. If you really want maximum performance I'm going to stay stop right here and use another language.

PHP 非常慢。这是不可否认的。它是最慢的语言之一。如果你真的想要最大的性能，我会在这里停下来使用另一种语言。

Chances are you don't need maximum performance as computers tend to be pretty powerful today and scaling or caching is an option. PHP also tends to become faster with new releases, especially PHP 7 so stating recent will likely give you free performance improvements. Differences between versions may make some micro optimizations pointless.

您可能不需要最高性能，因为今天的计算机往往非常强大，并且可以选择缩放或缓存。随着新版本的发布，PHP 也会变得更快，尤其是 PHP 7，所以声明最近可能会给你免费的性能改进。版本之间的差异可能会使一些微优化变得毫无意义。

Completely contrary to the statement about PHP being the slowest language around, you may find that in some cases it beats nearly every interpreted language out there. This is because PHP originally was meant as a very simple a wrapper for C and many of your PHP functions wrap C functions which makes them quite fast. This actually tends to be the case with most interpreted languages but it is far more noticeable in PHP.

与关于 PHP 是最慢的语言的说法完全相反，您可能会发现在某些情况下它几乎击败了所有解释性语言。这是因为 PHP 最初是作为 C 的一个非常简单的包装器，而您的许多 PHP 函数都包装了 C 函数，这使得它们非常快。这实际上往往是大多数解释型语言的情况，但在 PHP 中更为明显。

Contrary to that again some of in built functions may have performance issues where they try to do too much or aren't implemented well. I think until PHP 7 array_unique had been implemented in a very strange and excessively complex way where it would be quicker to use something such as array_flip and array_keys instead.

与此相反，一些内置函数可能会出现性能问题，因为它们试图做得太多或没有很好地实现。我认为直到 PHP 7 array_unique 以一种非常奇怪和过于复杂的方式实现之前，使用诸如 array_flip 和 array_keys 之类的东西会更快。

PHP is like that. It's one of the most outrageous languages out there as one with a collection of contradictory attributes that are extreme opposites. It's one of the most inconsistent yet the among the easiest to learn. PHP is one of the worst languages out there having grown organically more so than adhering to a design yet it it one of the most productive languages as a DSL for web development. PHP is very bad at scaling yet one of the most scalable web languages out there when run under Apache. I could go on but the point is to expect confusion when it comes to PHP.

PHP就是这样。它是最令人发指的语言之一，因为它具有一系列极端对立的矛盾属性。它是最不一致但最容易学习的方法之一。PHP 是最糟糕的语言之一，它的有机增长不仅仅是坚持设计，但它作为 Web 开发的 DSL 是最高效的语言之一。PHP 在扩展性方面非常糟糕，但在 Apache 下运行时，它是最具扩展性的 Web 语言之一。我可以继续，但重点是在 PHP 方面会出现混淆。

Ditching PHP is not without a cost. Productivity in PHP tends to be much higher than in other languages for webdev and the bar for entry is very low.

放弃 PHP 并非没有代价。PHP 的生产力往往比 webdev 的其他语言高得多，而且入门门槛非常低。

If you want to have the best of both worlds then simply make your PHP code as simple as possible with the goal primarily of it working than it being fast. The next step after this is to make sure you keep good logs so that you can find the requests that have the highest latency or take the most resources. Once you know this you can to targeted profiling. Think of it like this, your logs will tell you what file or request to profile, your profiling will tell you which lines or blocks of code are slow.

如果您想要两全其美，那么只需让您的 PHP 代码尽可能简单，其主要目标是工作而不是快速。此后的下一步是确保您保留良好的日志，以便您可以找到具有最高延迟或占用最多资源的请求。一旦你知道了这一点，你就可以进行有针对性的分析。可以这样想，您的日志会告诉您要分析的文件或请求，您的分析会告诉您哪些行或代码块很慢。

Don't forget though that it's often not PHP that's slow or hard to scale but other resources your PHP scripts depend on such as database.

但不要忘记，缓慢或难以扩展的通常不是 PHP，而是 PHP 脚本所依赖的其他资源，例如数据库。

General resource monitoring is also useful. For example if your ambient CPU usage is less than 5% why do anything unless latency crops up somewhere? This also helps to give you more hints about where PHP is stalling (where the bottlenecks are, network, HDD IO, memory, CPU, etc). Also keep in mind that today hardware is really really cheap and throwing hardware at problems may turn out much more effective. Such monitoring again allows a targeted approach. I'm an oldie with experience of limited hardware and I can tell you back in the day I used to prematurely optimize a lot. This would give a good return but today it just does not. Typically I can spend a month optimizing something and for the same cost of manhours buy some hardware that might result in a two times performance increase without the big effort. I would not take this too far, hardware does not solve everything but look at it like this, no matter how much you try to optimize there are hard limits presented by hardware so if you go too far in trying to make it work with poor hardware you will quickly hit the realm of diminishing returns.

常规资源监控也很有用。例如，如果您的环境 CPU 使用率低于 5%，为什么除非在某处出现延迟，否则为什么要做任何事情？这也有助于为您提供有关 PHP 停滞位置的更多提示（瓶颈在哪里，网络、HDD IO、内存、CPU 等）。还要记住，今天的硬件真的很便宜，把硬件扔在问题上可能会更有效。这种监控再次允许有针对性的方法。我是一个硬件经验有限的老手，我可以告诉你，我过去常常过早地优化很多。这会带来不错的回报，但今天却没有。通常，我可以花一个月的时间优化一些东西，并以相同的工时成本购买一些硬件，这些硬件可能会在不费力的情况下使性能提高两倍。我不会走得太远，

Once your find these problem areas you can then attempt to optimize them with better PHP or caching. In most cases this might be enough. Often you may find PHP is not the bottleneck but something else such as database access.

一旦找到这些问题区域，您就可以尝试使用更好的 PHP 或缓存来优化它们。在大多数情况下，这可能就足够了。通常，您可能会发现 PHP 不是瓶颈，而是其他因素，例如数据库访问。

If you find that you cannot optimize in PHP or with caching you have to think of something else. Using another language is an option and of course here comes the possibility of using C and then wrapping it in PHP as an extension. C is expensive to write in general so this approach lets you use it only where you need it or rather where you receive the most benefit. This is called hotspot optimisation.

如果您发现无法在 PHP 或缓存中进行优化，则必须考虑其他方法。使用另一种语言是一种选择，当然这里可以使用 C，然后将其包装在 PHP 中作为扩展。C 通常编写起来很昂贵，因此这种方法可以让您仅在需要的地方使用它，或者在您获得最大收益的地方使用它。这称为热点优化。

Outside of this there are many other alternatives and you need not wrap only C but if PHP can't do it, PHP can't do it. You can also consider scaling across multiple nodes or processes but keep in mind that in some cases PHP does not scale well when it comes to parallel processing due shared nothing (not many scaling loads need to share for a benefit).

除此之外还有许多其他选择，您不需要只包装 C，但是如果 PHP 不能做到，PHP 也不能做到。您还可以考虑跨多个节点或进程进行扩展，但请记住，在某些情况下，PHP 在并行处理时无法很好地扩展，因为不共享（不需要共享很多扩展负载以获得好处）。

Whatever you decide, when it comes down to it, we can give 1000 tips about micro-optimisation. Perhaps one of the best all round ones I can give you it to try to put as much into as few PHP native functions as possible because these will run bulk operations in C much faster. You should also follow good theoretical concepts when it comes to algorithm design about things such as time complexity because these are universally applicable. In fact, the majority of performance tips people can give you are probably going to be general programming concepts and not specific to PHP. I would also suggest avoiding library bloat or bulky frameworks. The more they promise the more likely it is to be too good to be true in the real world. Simplicity is key and while libraries are always good think first, are you including ten thousand lines of code to save you writing ten lines out of a hundred which you could turn into a function and reuse yourself.

无论您做出什么决定，归根结底，我们都可以提供 1000 条关于微优化的提示。也许是我可以给你的最好的全面功能之一，尝试将尽可能多的 PHP 本地函数放入尽可能少的 PHP 本地函数中，因为这些将在 C 中更快地运行批量操作。在涉及诸如时间复杂度之类的算法设计时，您还应该遵循良好的理论概念，因为它们是普遍适用的。事实上，人们可以提供的大多数性能技巧可能都是通用的编程概念，而不是特定于 PHP 的。我还建议避免库膨胀或庞大的框架。他们承诺的越多，就越有可能在现实世界中变得好得令人难以置信。简单是关键，虽然图书馆总是好的，但首先要思考，

Using Opcache or APC if using versions of PHP below 5.5 will instantly give a good speed improvement on PHP parse times and make this a non-concern. PHP 5.5 should have it built in but make sure it's enabled.

如果使用低于 5.5 的 PHP 版本，则使用 Opcache 或 APC 将立即对 PHP 解析时间提供良好的速度改进，并使这成为无关紧要的问题。PHP 5.5 应该内置它，但请确保它已启用。

The topic of what is faster than what in what situation pits thousands of things against thousands of things so your best bet is to study and learn more about what PHP actually is, how it works, and how to measure, test and analyse performance. If you have a good sense of how PHP works under the hood you'll be able to better intuit problems when they do arise. Optimizing ten lines of code can become a 10000 word debate. Imagine your application when it has thousands of lines of code.

在什么情况下什么比什么更快的主题使成千上万的事物与成千上万的事物相抗衡，因此最好的办法是研究和了解更多关于 PHP 实际是什么、它是如何工作的以及如何衡量、测试和分析性能的信息。如果您对 PHP 在幕后的工作方式有很好的了解，那么当问题确实出现时，您将能够更好地凭直觉判断问题。优化十行代码可以变成10000字的辩论。想象一下您的应用程序有数千行代码。

I do understand in a few cases the importance or benefit of pre-emptive and micro optimization (largely consists of avoiding performance quirks in languages where performance is disproportionately reduced). However in reality it is usually next to impossible to achieve the kind of gains you expect (again though I have to say the biggest impact you can have if you really care about performance is to ditch PHP altogether, basically this can be seen like asking how can I make a snail fast, the answer is if speed it so important use something built for that). Even the experienced and knowledgeable can have a hard time with this. Almost no one gets it right first time. So where you really want to spend efforts on is maintainability. Keep your code consistent, tidy and well organised. Used VCS to be able to easily delete things (don't comment out code or rename files to .old). Make sure you stay DRY and in general follow good practices. TIAS, Google, etc.

在某些情况下，我确实理解先发制人和微优化的重要性或好处（主要包括避免性能不成比例地降低的语言中的性能怪癖）。然而，实际上通常几乎不可能实现您期望的那种收益（尽管我不得不说，如果您真的关心性能，您可以获得的最大影响就是完全放弃 PHP，基本上这可以看作是问如何我可以让蜗牛变快吗？答案是，如果速度如此重要，请使用为此构建的东西）。即使是经验丰富且知识渊博的人也可能对此感到困难。几乎没有人第一次就做对了。所以你真正想要花精力的地方是可维护性。保持您的代码一致、整洁和组织良好。使用 VCS 能够轻松删除东西（不要 t 注释掉代码或将文件重命名为 .old）。确保您保持干燥并遵循良好的做法。TIAS、谷歌等

回答by Daimon

Usually pre-mature optimization is a veeeery bad idea. It really doesn't matter when you make your code run 0.5ms faster when single SQL query takes 80ms.

通常过早的优化是一个非常糟糕的主意。当单个 SQL 查询需要 80 毫秒时，让您的代码运行速度快 0.5 毫秒真的无关紧要。

You should profile code and focus on bottle necks and then try things like caching (static, APC, Memcached). Microoptimizations are the very last step when you've got perfect application design and still need more performance from certain modules/functions.

您应该分析代码并关注瓶颈，然后尝试缓存（静态、APC、Memcached）之类的方法。当您拥有完美的应用程序设计但仍需要某些模块/功能的更高性能时，微优化是最后一步。

回答by Ismael Miguel

Lets imagine you have an array of words.
Like this: $words=array('banana','cat','tuna','bicycle','kitten','caffeine');

假设您有一组单词。
像这样：$words=array('banana','cat','tuna','bicycle','kitten','caffeine');

And then you have a search term to find, like this: $find='ca';

然后你有一个搜索词要查找，如下所示： $find='ca';

And you want to know all the elements that startwith that given term.

并且您想知道以该给定术语开头的所有元素。

We would usually do like this:

我们通常会这样做：

foreach($words as &$word)if(preg_match('@^'.$find.'@',$word))echo $word,'<br>';

Or the fastest way:

或者最快的方法：

foreach($words as &$word)if(strpos($find,$word)==0)echo $word,'<br>';

But why don't we just do like this:

但我们为什么不这样做：

foreach($words as &$word)if($find==($find&$word))echo $word,'<br>';

You shave off a few bytes AND it is faster 'cause you don't have to waste time calling functions.

您减少了几个字节并且速度更快，因为您不必浪费时间调用函数。

回答by symcbean

This question (and the answers) are rather dated however it came up high in the listings when I googled for 'PHP performance'.

这个问题（和答案）已经过时了，但是当我在 google 上搜索“PHP 性能”时，它在列表中名列前茅。

While jgmjgm makes some good points, the execution time of PHP is typically a tiny proportion of the time a user spends waiting for a page to appear, but explaining why, let alone detailing the remedieswould take far too long here.

虽然 jgmjgm 提出了一些好处，但 PHP 的执行时间通常只占用户等待页面出现时间的一小部分，但解释原因，更不用说详细说明补救措施会花费太长时间。

The first step is to identify the things which are taking the most time - and for a web based application you should start at the browser. Google Chrome has a good profiler and for Firefox, there is the Firebug extension. If the slow bit is PHP then dig further with a profiler such as xdebug, but remember that this will encompass any database and file IO.

第一步是确定花费最多时间的事情 - 对于基于 Web 的应用程序，您应该从浏览器开始。谷歌浏览器有一个很好的分析器，对于 Firefox，有 Firebug 扩展。如果较慢的位是 PHP，则使用分析器（例如 xdebug）进一步挖掘，但请记住，这将包含任何数据库和文件 IO。

回答by Martin Fasani

It's obvious, but creating objects is also costly, so for ex. if you need a timestamp doing a time() is double faster than doing a date_create()->getTimestamp.

很明显，但是创建对象也很昂贵，因此例如。如果您需要时间戳，则 time() 比 date_create()->getTimestamp 快两倍。

for ($a=1;$a<1000000;$a++) {
  $e = time(); // In my tests about 2x faster than:
  //$e = date_create()->getTimestamp();
}

回答by Mohd Bashir

1. Use Native PHP Functions
2. Use Single Quotes
   Using single quotes ( ‘ ‘ ) is faster than using double quotes( ” ” )
3. Use = = =
   Use “= = =” instead of “= =”,

4. Calculate Only Once Calculate and assign the value to the variable if that value is getting used numerous time rather than calculating it again and again where it is being used.

   For example, the following will degrade the performance.

   for( $i=0; i< count($arrA); $i++){
   
    echo count($arrA);
   }
   

   The script below will perform much better.

   $len = count($arrA);
   
   for( $i=0; i< $len; $i++){
   echo $len;
   

   }

5. Used Switch Cases

6. Use JSON

1. 使用原生 PHP 函数
2. 使用单引号
   使用单引号 ( ' ' ) 比使用双引号 ( ” ” ) 快
3. 使用 ==
   使用“==”代替“==”，

4. 仅计算一次 如果该值被多次使用，而不是在使用它的地方一次又一次地计算它，则计算并将该值分配给该变量。

   例如，以下内容会降低性能。

   for( $i=0; i< count($arrA); $i++){
   
    echo count($arrA);
   }
   

   下面的脚本会表现得更好。

   $len = count($arrA);
   
   for( $i=0; i< $len; $i++){
   echo $len;
   

   }

5. 二手开关盒

6. 使用 JSON

Use JSON instead of XML while working with web services as there are native php function like json_encode( ) and json_decode( ) which are very fast. 7. Use isset Use isset( ) where ever possible instead of using count( ), strlen( ), sizeof( ) to check whether the value returned is greater than 0.

在处理 Web 服务时使用 JSON 而不是 XML，因为有像 json_encode() 和 json_decode() 这样的原生 php 函数，它们非常快。7.使用isset 尽可能使用isset()而不是使用count()、strlen()、sizeof()来检查返回的值是否大于0。

1. Concatening variables is faster than just putting them in a double-quotation mark string.

8. 连接变量比将它们放在双引号字符串中要快。