Teilen von Beispielen zur PHP-Leistungsoptimierung

In diesem Artikel werden hauptsächlich Beispiele zur PHP-Leistungsoptimierung aufgeführt. Dieser Artikel listet viele Punkte auf und hofft, allen zu helfen.

1. Machen Sie es so statisch wie möglich:

Wenn eine Methode statisch sein kann, kann die Geschwindigkeit um 1/4 erhöht werden um fast das Dreifache erhöht.
Natürlich muss diese Testmethode auf Stufe 100.000 oder höher ausgeführt werden, damit der Effekt offensichtlich ist.
Tatsächlich besteht der Hauptunterschied in der Effizienz zwischen statischen Methoden und nicht statischen Methoden im Speicher: Statische Methoden generieren Speicher, wenn das Programm gestartet wird, und Instanzmethoden generieren Speicher, während das Programm ausgeführt wird, sodass statische Methoden direkt aufgerufen werden können. und Instanzmethoden müssen zunächst eine Instanz generieren. Der Aufruf von Methoden über Instanzen ist statisch sehr schnell, beansprucht jedoch mehr Speicher.
Ob jede Sprache objektorientiert ist oder nicht, ist nur eine Frage der Softwareschicht. Die unterste Ebene ist dieselbe, aber die Implementierungsmethode ist unterschiedlich. Der statische Speicher ist kontinuierlich, da er zu Beginn des Programms generiert wird, während die Instanz diskreten Speicherplatz beansprucht. Daher ist er natürlich nicht so schnell wie die statische Methode.
Statische Methoden rufen immer denselben Speicher auf. Der Nachteil besteht darin, dass er nicht automatisch zerstört werden kann, sondern durch Instanziierung.

2. Echo ist effizienter als print, da echo keinen Rückgabewert hat und print eine Ganzzahl zurückgibt.

Echo

0,000929 - 0,001255 s (durchschnittlich 0,001092 Sekunden)
Drucken
0,000980 - 0,001396 Sekunden (durchschnittlich 0,001188 Sekunden)
Der Unterschied beträgt etwa 8 % und das Echo ist insgesamt schneller.
Beachten Sie, dass beim Echo einer großen Zeichenfolge die Leistung erheblich beeinträchtigt wird, wenn keine Anpassungen vorgenommen werden. Verwenden Sie mod_deflate, um Apached zur Komprimierung zu öffnen, oder öffnen Sie ob_start, um den Inhalt zuerst in den Puffer zu stellen.

3. Stellen Sie die maximale Anzahl von Schleifen vor der Schleife ein, nicht während der Schleife.

Das verstehen alle Dummköpfe.

4. Zerstören Sie Variablen, um Speicher freizugeben, insbesondere große Arrays.

Arrays und Objekte belegen viel Speicher in PHP.

Im Allgemeinen Die Speicherauslastung von PHP-Arrays beträgt also nur 1/10. Das heißt, ein Array mit 100 MB Speicher in der C-Sprache erfordert 1 GB in PHP.

Insbesondere in Systemen, in denen PHP als Backend-Server verwendet wird, tritt häufig das Problem eines übermäßigen Speicherverbrauchs auf.

5. Vermeiden Sie die Verwendung magischer Methoden wie __get, __set, __autoload (nur als Referenz

, Diskussion vorbehalten

Benennen Sie sie für Funktionen, die mit __ beginnen). Auf solche Funktionen wird zunächst unter bestimmten Bedingungen zugegriffen. Im Allgemeinen gibt es die folgenden magischen Funktionen __construct(), __destruct(), __get(), __set(), __unset(), __call(), __callStatic(), __sleep(), __wakeup(), __toString ( ), __set_state(), __clone(), __autoload()

In der Tat, wenn __autoload den Klassennamen nicht effizient mit der tatsächlichen Festplattendatei kombinieren kann (beachten Sie, dass sich dies auf die tatsächliche Festplattendatei bezieht, nicht nur auf den Dateinamen ), muss das System eine große Anzahl von Beurteilungen darüber treffen, ob Dateien vorhanden sind (die in den in jedem Include-Pfad enthaltenen Pfaden durchsucht werden müssen), und um zu beurteilen, ob Dateien vorhanden sind, sind Festplatten-E/A-Vorgänge erforderlich. Festplatten-E/A-Vorgänge Die Effizienz von /O-Vorgängen ist sehr gering, daher ist der Autoload-Mechanismus aus diesem Grund weniger effizient.

Daher müssen wir beim Entwurf des Systems einen klaren Mechanismus für die Zuordnung von Klassennamen zu tatsächlichen Festplattendateien definieren. Je einfacher und klarer diese Regel ist, desto effizienter ist der Autoload-Mechanismus.

Fazit: Der Autoload-Mechanismus ist nicht von Natur aus ineffizient. Nur der Missbrauch von Autoload und schlecht gestaltete Autoload-Funktionen führen zu einer Verringerung seiner Effizienz.

Vermeiden Sie daher die Verwendung der __autoload-Magie ist fraglich.

6.requiere_once() ist relativ ressourcenintensiv;

Dies liegt daran, dass requirere_once feststellen muss, ob auf die Datei verwiesen wurde), sodass sie nicht so oft wie möglich verwendet wird . Häufig verwendete „require/include“-Methoden sollten vermieden werden.

7. Verwenden Sie absolute Pfade in Includes und Requires.

Wenn ein relativer Pfad enthalten ist, durchläuft PHP den include_path, um die Datei zu finden.

Durch die Verwendung absoluter Pfade werden solche Probleme vermieden, sodass die Auflösung des Betriebssystempfads weniger Zeit in Anspruch nimmt.

8. Wenn Sie die Zeit benötigen, zu der das Skript ausgeführt wird, ist $_SERVER['REQUSET_TIME'] besser als time(); Einer ist fertig und kann direkt verwendet werden, der andere erfordert das von der Funktion erhaltene Ergebnis.

9. Wenn Sie die internen String-Manipulationsfunktionen verwenden können, versuchen Sie, diese anstelle regulärer Ausdrücke zu verwenden.

Selbstverständlich verbrauchen reguläre Ausdrücke die meiste Leistung.
Gibt es nützliche Funktionen, die Sie vermisst haben? Beispiel: strpbrk()strncasecmp()strpos()/strrpos()/stripos()/strripos() beschleunigt strtr. Wenn Sie nur ein einzelnes Zeichen konvertieren müssen,
Verwenden Sie einen String anstelle eines Arrays do strtr:

<?php
$addr = strtr($addr, "abcd", "efgh"); // good
$addr = strtr($addr, array(&#39;a&#39; => &#39;e&#39;, )); // bad
?>

Effizienzverbesserung: 10-mal.

10. Das Ersetzen von str_replace-Zeichen ist schneller als das normale Ersetzen von preg_replace, aber strtr ist 1/4 schneller als str_replace.

Nehmen Sie außerdem keine unnötigen Ersetzungen vor Kein Ersatz, str_replace wird sein. Seine Parameter weisen Speicher zu. Sehr langsam! Lösung:
Verwenden Sie strpos, um zuerst zu suchen (sehr schnell), um zu sehen, ob ein Austausch erforderlich ist. Effizienz: - Wenn ein Austausch erforderlich ist: Die Effizienz ist nahezu gleich und der Unterschied beträgt etwa 0,1 %.
Wenn kein Ersatz benötigt wird: Strpos 200 % schneller verwenden.

11. Der Parameter ist eine Zeichenfolge

Wenn eine Funktion sowohl Arrays als auch einfache Zeichen als Parameter akzeptieren kann, z. B. eine Zeichenersetzungsfunktion, und die Parameterliste nicht zu lang ist, ist dies möglich Erwägen Sie das Schreiben eines zusätzlichen Ersatzcodes, sodass jeder übergebene Parameter ein Zeichen ist, anstatt Arrays als Such- und Ersetzungsparameter zu akzeptieren. Machen Sie große Dinge klein, 1+1>2;

12 Es ist am besten, @ nicht zu verwenden, da die Verwendung von @ zum Vertuschen von Fehlern die Ausführungsgeschwindigkeit des Skripts verringert;

Verwendung von @. Tatsächlich sind viele Vorgänge im Hintergrund erforderlich. Der Effizienzunterschied zwischen der Verwendung von @ und der Nichtverwendung von @ beträgt: 3-mal. Verwenden Sie @ insbesondere nicht in einer Schleife, selbst wenn Sie error_reporting(0) verwenden, um den Fehler zuerst auszuschalten und ihn dann wieder einzuschalten, nachdem die Schleife abgeschlossen ist, ist dies schneller als die Verwendung von @.

13.$row['id'] ist 7-mal schneller als $row[id]

Es wird empfohlen, die Gewohnheit zu entwickeln, Anführungszeichen zu Array-Schlüsseln hinzuzufügen;

14. Verwenden Sie keine Funktionen

in Schleifen. Zum Beispiel: For($x=0; $x 2c53bff3014e4efa511ce535119eeb83prop++) ist dreimal langsamer als eine lokale Variable;

19 .Das Erstellen einer nicht deklarierten lokalen Variablen ist 9-10-mal langsamer als das Erstellen einer definierten lokalen Variablen

20. Das Deklarieren einer globalen Variablen, die von keiner Funktion verwendet wurde, verringert ebenfalls die Leistung (und die Deklaration derselben Anzahl lokaler Variablen). Variablen).

PHP prüft möglicherweise, ob diese globale Variable vorhanden ist.

21 Die Leistung der Methode hat nichts mit der Anzahl der in einer Klasse definierten Methoden zu tun.

Weil ich hinzugefügt habe 10 Es gibt keinen Leistungsunterschied nach dem Hinzufügen mehrerer Methoden oder Methoden zur getesteten Klasse (diese Methoden liegen vor und nach der Testmethode).

22 Die Leistung von Methoden in Unterklassen ist besser als in Basisklassen ;

23. Die Zeit, die zum Ausführen einer Funktion benötigt wird, die nur einen Parameter aufruft und einen leeren Funktionskörper hat, entspricht 7-8 $localvar++-Operationen, während eine ähnliche Methode (Funktion in einer Klasse) gleich ausgeführt wird auf etwa 15 $localvar++-Operationen;

24 Verwenden Sie einfache Anführungszeichen anstelle von doppelten Anführungszeichen, um Zeichenfolgen einzuschließen, was schneller ist.

Weil PHP nach Variablen in einer Zeichenfolge sucht, die von doppelten Anführungszeichen, aber nicht von einfachen Anführungszeichen umgeben ist.

Die PHP-Engine erlaubt die Verwendung von einfachen und doppelten Anführungszeichen zum Kapseln von String-Variablen, aber es gibt einen großen Unterschied! Durch die Verwendung von Zeichenfolgen in doppelte Anführungszeichen wird die PHP-Engine angewiesen, zunächst den Inhalt der Zeichenfolge zu lesen, die darin enthaltenen Variablen zu finden und sie in die Werte zu ändern, die den Variablen entsprechen. Im Allgemeinen haben Zeichenfolgen keine Variablen, daher führt die Verwendung von doppelten Anführungszeichen zu einer schlechten Leistung. Es ist besser, die Zeichenfolgenverkettung

anstelle von Zeichenfolgen in doppelten Anführungszeichen zu verwenden.

BAD:
$output = "This is a plain string";
GOOD:
$output = 'This is a plain string';
BAD: 
$type = "mixed";
$output = "This is a $type string";
GOOD:
$type = 'mixed';
$output = 'This is a ' . $type .' string';

25. Es ist schneller, beim Echo von Zeichenfolgen Kommas anstelle von Punktkonnektoren zu verwenden.

echo ist eine „Funktion“, die mehrere Strings als Parameter annehmen kann (Anmerkung: Im PHP-Handbuch heißt es, dass echo eine Sprachstruktur und keine echte Funktion ist, daher wird die Funktion in doppelte Anführungszeichen gesetzt).

  例如echo $str1,$str2。

26.Apache解析一个PHP脚本的时间要比解析一个静态HTML页面慢2至10倍。

     尽量多用静态HTML页面，少用脚本。

28.尽量使用缓存，建议用memcached。

   高性能的分布式内存对象缓存系统，提高动态网络应用程序性能，减轻数据库的负担;

   也对运算码 (OP code)的缓存很有用，使得脚本不必为每个请求做重新编译。

29.使用ip2long()和long2ip()函数把IP地址转成整型存放进数据库而非字符型。

     这几乎能降低1/4的存储空间。同时可以很容易对地址进行排序和快速查找;

30.使用checkdnsrr()通过域名存在性来确认部分email地址的有效性

    这个内置函数能保证每一个的域名对应一个IP地址;

31.使用mysql_*的改良函数mysqli_*;

32.试着喜欢使用三元运算符(?：);

33.是否需要PEAR

在你想在彻底重做你的项目前，看看PEAR有没有你需要的。PEAR是个巨大的资源库，很多php开发者都知道;

35.使用error_reporting(0)函数来预防潜在的敏感信息显示给用户。

  理想的错误报告应该被完全禁用在php.ini文件里。可是如果你在用一个共享的虚拟主机，php.ini你不能修改，那么你最好添加error_reporting(0)函数，放在每个脚本文件的第一行(或用

require_once()来加载)这能有效的保护敏感的SQL查询和路径在出错时不被显示;

36.使用 gzcompress() 和gzuncompress()对容量大的字符串进行压缩(解压)在存进(取出)数据库时。

    这种内置的函数使用gzip算法能压缩到90%;

37.通过参数变量地址得引用来使一个函数有多个返回值。

   你可以在变量前加个“&”来表示按地址传递而非按值传递;

38. 完全理解魔术引用和SQL注入的危险。

    Fully understand “magic quotes” and the dangers of SQL injection. I’m hoping that most developers reading this are already familiar with SQL injection. However, I list it here because it’s absolutely critical to understand. If you’ve never heard the term before, spend the entire rest of the day googling and reading.

39.某些地方使用isset代替strlen

  当操作字符串并需要检验其长度是否满足某种要求时，你想当然地会使用strlen()函数。此函数执行起来相当快，因为它不做任何计算，只返回在zval 结构（C的内置数据结构，用于存储PHP变量）中存储的已知字符串长度。但是，由于strlen()是函数，多多少少会有些慢，因为函数调用会经过诸多步骤，如字母小写化（译注：指函数名小写化，PHP不区分函数名大小写）、哈希查找，会跟随被调用的函数一起执行。在某些情况下，你可以使用isset() 技巧加速执行你的代码。

（举例如下）if (strlen($foo) < 5) { echo “Foo is too short”
} （与下面的技巧做比较） if (!isset($foo{5})) { echo “Foo is too short”
}

调用isset()恰巧比strlen()快，因为与后者不同的是，isset()作为一种语言结构，意味着它的执行不需要函数查找和字母小写化。也就是说，实际上在检验字符串长度的顶层代码中你没有花太多开销。

40.使用++$i递增

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 preincrementation 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.

   当执行变量$i的递增或递减时，$i++会比++$i慢一些。这种差异是PHP特有的，并不适用于其他语言，所以请不要修改你的C或Java代码并指望它们能立即变快，没用的。++$i更快是因为它只需要3条指令(opcodes)，$i++则需要4条指令。后置递增实际上会产生一个临时变量，这个临时变量随后被递增。而前置递增直接在原值上递增。这是最优化处理的一种，正如Zend的PHP优化器所作的那样。牢记这个优化处理不失为一个好主意，因为并不是所有的指令优化器都会做同样的优化处理，并且存在大量没有装配指令优化器的互联网服务
提供商（ISPs）和服务器。

40. 不要随便就复制变量

有时候为了使 PHP 代码更加整洁，一些 PHP 新手（包括我）会把预定义好的变量复制到一个名字更简短的变量中，其实这样做的结果是增加了一倍的内存消耗，只会使程序更加慢。试想一下，在下面的例子中，如果用户恶意插入 512KB 字节的文字到文本输入框中，这样就会导致 1MB 的内存被消耗！

BAD:
$description = $_POST['description'];
echo $description;
GOOD:
echo $_POST['description'];

41 使用选择分支语句

     switch case好于使用多个if，else if语句,并且代码更加容易阅读和维护。

42.在可以用file_get_contents替代file、fopen、feof、fgets

    在可以用file_get_contents替代file、fopen、feof、fgets等系列方法的情况下，尽量用file_get_contents，因为他的效率高得多！但是要注意file_get_contents在打开一个URL文件时候的PHP版本问题；

43.尽量的少进行文件操作，虽然PHP的文件操作效率也不低的；

44.优化Select SQL语句，在可能的情况下尽量少的进行Insert、Update操作(在update上，我被恶批过)；

45.尽可能的使用PHP内部函数

46.循环内部不要声明变量，尤其是大变量：对象

   (这好像不只是PHP里面要注意的问题吧？)；

47.多维数组尽量不要循环嵌套赋值；

48.foreach效率更高，尽量用foreach代替while和for循环；

50.对global变量，应该用完就unset()掉；

51 并不是事必面向对象(OOP)，面向对象往往开销很大，每个方法和对象调用都会消耗很多内存。

52 不要把方法细分得过多，仔细想想你真正打算重用的是哪些代码？

53 如果在代码中存在大量耗时的函数，你可以考虑用C扩展的方式实现它们。

54、压缩输出：打开apache的mod_deflate模块，可以提高网页的浏览速度。

   （提到过echo 大变量的问题）

55、数据库连接当使用完毕时应关掉，不要用长连接。

56、split比exploade快

split()
0.001813 - 0.002271 seconds (avg 0.002042 seconds)
explode()
0.001678 - 0.003626 seconds (avg 0.002652 seconds)
Split can take regular expressions as delimiters, and runs faster too. ~23% on average.

以上都是关于php代码的优化，下面是从整体结构方面优化PHP性能：

整体结构方面优化PHP性能

1.将PHP升级到最新版

　　提高性能的最简单的方式是不断升级、更新PHP版本。

2.使用分析器

　　网站运行缓慢的原因颇多，Web应用程序极其复杂，让人扑朔迷离。而一种可能性在于PHP代码本身。这个分析器可以帮助你快速找出造成瓶颈的代码，提高网站运行的总体性能。

　　Xdebug PHP extension提供了强大的功能，可以用来调试，也可以用来分析代码。方便开发人员直接跟踪脚本的执行，实时查看综合数据。还可以将这个数据导入到可视化的工具 KCachegrind中。

3.检错报告

　　PHP支持强大的检错功能，方便你实时检查错误，从比较重要的错误到相对小的运行提示。总共支持13种独立的报告级别，你可以根据这些级别灵活匹配，生成用户自定义的检测报告。

4.利用PHP的扩展

Jeder hat sich immer darüber beschwert, dass PHP-Inhalte zu komplex sind. In den letzten Jahren haben Entwickler entsprechende Anstrengungen unternommen, um einige redundante Funktionen aus dem Projekt zu entfernen. Dennoch ist die Anzahl der verfügbaren Bibliotheken und anderen Erweiterungen beeindruckend. Einige Entwickler beginnen sogar darüber nachzudenken, eigene Erweiterungen zu implementieren.

5. PHP-Cache, PHP-Beschleuniger verwenden: APC

Im Allgemeinen werden PHP-Skripte von der PHP-Engine kompiliert und ausgeführt und auch in Maschinensprache konvertiert bekannt als der Operationscode. Wenn ein PHP-Skript nach der Kompilierung immer wieder das gleiche Ergebnis erhält, warum nicht den Kompilierungsprozess komplett überspringen?

Mit dem PHP-Beschleuniger können Sie dies erreichen, der den Maschinencode des kompilierten PHP-Skripts zwischenspeichert. Ermöglicht die sofortige Ausführung von Code auf Anfrage, ohne dass ein langwieriger Kompilierungsprozess durchgeführt werden muss.

Für PHP-Entwickler stehen derzeit zwei Caching-Lösungen zur Verfügung. Eine davon ist APC (Alternative PHP Cache, optionaler PHP-Cache), ein Open-Source-Beschleuniger, der über PEAR installiert werden kann. Eine weitere beliebte Lösung ist Zend Server, der nicht nur Opcode-Caching-Technologie, sondern auch Caching-Tools für entsprechende Seiten bereitstellt.

6. Speichercache

PHP spielt normalerweise eine wichtige Rolle beim Abrufen und bei der Datenanalyse, und diese Vorgänge können zu Leistungseinbußen führen. Tatsächlich sind einige Vorgänge völlig unnötig, insbesondere das wiederholte Abrufen einiger häufig verwendeter statischer Daten aus der Datenbank. Möglicherweise möchten Sie kurzfristig die Verwendung der Memcached-Erweiterung zum Zwischenspeichern von Daten in Betracht ziehen. Der erweiterte Cache von Memcached arbeitet mit der libMemcached-Bibliothek zusammen, um Daten im RAM zwischenzuspeichern, und ermöglicht es Benutzern außerdem, den Cache-Zeitraum zu definieren, was dazu beiträgt, Echtzeitaktualisierungen von Benutzerinformationen sicherzustellen.

7.Inhaltskomprimierung:

Fast alle Browser unterstützen die Gzip-Komprimierungsmethode. Gzip kann die Ausgabe um 80 % reduzieren. Die Kosten betragen etwa 10 % mehr CPU-Berechnungen. Was Sie jedoch davon haben, ist, dass nicht nur die belegte Bandbreite reduziert wird, sondern auch das Laden Ihrer Seite schneller wird, wodurch die Leistung Ihrer PHP-Site optimiert wird.
Sie können es in PHP.ini aktivieren
zlib.output_compression = On
zlib.output_compression_level = (level) (level kann eine Zahl zwischen 1 und 9 sein, Sie können verschiedene Zahlen festlegen, um es geeignet zu machen )
Wenn Sie Apache verwenden, können Sie auch das mod_gzip-Modul aktivieren, das hochgradig anpassbar ist.

8. Server-Cache:

Basiert hauptsächlich auf den statischen Servern Nginx und Squid, die auf Web-Reverse-Proxy basieren, sowie den Modulen mod_proxy und mod_cache von Apache2

9. Datenbankoptimierung: Datenbank-Caching usw.

Durch Konfigurieren des Datenbankcaches, z. B. durch Einschalten des QueryCache-Cache, wenn die Abfrage eine gleiche Abfrage empfängt Wie zuvor ruft der Server die Ergebnisse aus dem Abfragecache ab, anstatt die letzte Abfrage erneut zu analysieren und auszuführen
und Datenspeicherverfahren, Verbindungspooltechnologie usw.

Verwandte Empfehlungen:

Weitergabe von Tipps zur PHP-Leistungsoptimierung

Detaillierte Beispiele zur PHP-Leistungsoptimierung

Fünf Tipps zur PHP-Leistungsoptimierung

Das obige ist der detaillierte Inhalt vonTeilen von Beispielen zur PHP-Leistungsoptimierung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!