Partage d'exemples d'optimisation des performances PHP

Cet article partage principalement avec vous des exemples d'optimisation des performances PHP. Cet article répertorie de nombreux points, en espérant aider tout le monde.

1. Rendez-la aussi statique que possible :

Si une méthode peut être statique, déclarez-la comme statique, et la vitesse peut être augmentée de 1/4. Même lorsque j'ai testé, cela. augmenté de près de trois fois.
Bien entendu, cette méthode de test doit être exécutée au niveau 100 000 ou supérieur pour que l'effet soit évident.
En fait, la principale différence d'efficacité entre les méthodes statiques et les méthodes non statiques est la mémoire : les méthodes statiques génèrent de la mémoire au démarrage du programme, et les méthodes d'instance génèrent de la mémoire pendant l'exécution du programme, donc les méthodes statiques peuvent être appelées directement, et les méthodes d'instance doivent d'abord générer une instance. L'appel de méthodes via des instances est très rapide statiquement, mais prendra plus de mémoire.
Tout langage fonctionne sur la mémoire et le disque. Quant à savoir s'il est orienté objet ou non, c'est juste une question de couche logicielle. La couche inférieure est la même, mais la méthode d'implémentation est différente. La mémoire statique est continue car elle est générée au début du programme, tandis que l'instance s'applique à l'espace discret, donc bien sûr elle n'est pas aussi rapide que la méthode statique.
Les méthodes statiques appellent toujours la même mémoire. L'inconvénient est qu'elle ne peut pas être détruite automatiquement, mais peut être détruite par instanciation.

2. Echo est plus efficace que print car echo n'a pas de valeur de retour et print renvoie un entier

Test :
Echo
0,000929 - 0,001255 s (0,001092 secondes en moyenne)
Impression
0,000980 - 0,001396 secondes (moyenne 0,001188 secondes)
La différence est d'environ 8 % et l'écho global est plus rapide.
Notez que lors de l'écho de grandes cordes, si aucun réglage n'est effectué, les performances seront sérieusement affectées. Utilisez mod_deflate pour ouvrir Apache pour la compression ou ouvrez ob_start pour mettre d'abord le contenu dans le tampon.

3. Fixez le nombre maximum de boucles avant la boucle, pas pendant la boucle

Tous les imbéciles comprennent cela ;

4. Détruisez les variables pour libérer de la mémoire, en particulier les grands tableaux ;

Les tableaux et les objets occupent beaucoup de mémoire en PHP,
Généralement. En parlant, l'utilisation de la mémoire des tableaux PHP n'est que de 1/10, c'est-à-dire qu'un tableau avec 100 Mo de mémoire en langage C nécessite 1 Go en PHP.
Surtout dans les systèmes où PHP est utilisé comme serveur backend, le problème d'une consommation excessive de mémoire se produit souvent.

5. Évitez d'utiliser des méthodes magiques telles que __get, __set, __autoload (pour référence seulement , sous réserve de discussion

Pour les fonctions commençant par __, nommez-les Magic) ; fonctions, ces fonctions sont d’abord accessibles dans des conditions spécifiques. En général, il existe les fonctions magiques suivantes

__construct(), __destruct(), __get(), __set(), __unset(), __call(), __callStatic(), __sleep(), __wakeup(), __toString ( ), __set_state(), __clone(), __autoload()

En fait, si __autoload ne peut pas combiner efficacement le nom de la classe avec le fichier disque réel (notez que cela fait référence au fichier disque réel, pas seulement au nom du fichier ), le système devra faire un grand nombre de jugements pour savoir si les fichiers existent (qui doivent être recherchés dans les chemins inclus dans chaque chemin d'inclusion), et juger si les fichiers existent nécessite des opérations d'E/S sur disque. Comme nous le savons tous, Opérations d'E/S disque L'efficacité des opérations /O est très faible, c'est donc ce qui rend le mécanisme de chargement automatique moins efficace.

Par conséquent, lors de la conception du système, nous devons définir un mécanisme clair pour mapper les noms de classe aux fichiers de disque réels. Plus cette règle est simple et claire, plus le mécanisme de chargement automatique sera efficace.

Conclusion : Le mécanisme de chargement automatique n'est pas naturellement inefficace. Seul un abus de l'autoload et des fonctions de chargement automatique mal conçues entraîneront une réduction de son efficacité

Essayez donc d'éviter d'utiliser la méthode magique __autoload. est sujette à caution.

6.requiere_once() est relativement gourmand en ressources ;

En effet, requirere_once doit déterminer si le fichier a été référencé), il doit donc être utilisé le moins possible. Méthodes require/include couramment utilisées à éviter.

7. Utilisez des chemins absolus dans les inclusions et les exigences.

Si un chemin relatif est inclus, PHP parcourra le include_path pour trouver le fichier.

L'utilisation de chemins absolus évitera de tels problèmes, il faudra donc moins de temps pour résoudre le chemin du système d'exploitation.

8. Si vous avez besoin d'obtenir l'heure à laquelle le script est exécuté, $_SERVER['REQUSET_TIME'] est meilleur que time();

Comme vous pouvez l'imaginer. L'un est prêt à l'emploi et peut être utilisé directement, et l'autre nécessite le résultat obtenu par la fonction.

9. Si vous pouvez utiliser les fonctions internes de manipulation de chaînes de PHP, essayez de les utiliser à la place des expressions régulières ; car leur efficacité est supérieure à celle des expressions régulières

Inutile de dire que les expressions régulières consomment le plus de performances ;
Y a-t-il des fonctions utiles que vous avez manquées ? Par exemple : strpbrk()strncasecmp()strpos()/strrpos()/stripos()/strripos() accélère strtr Si tout ce dont vous avez besoin pour convertir est un seul caractère,
Utilisez une chaîne au lieu d'un tableau pour. do strtr :

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

Amélioration de l'efficacité : 10 fois.

10. Le remplacement du caractère str_replace est plus rapide que le remplacement régulier preg_replace, mais strtr est 1/4 plus rapide que str_replace

De plus, n'effectuez pas de remplacements inutiles. pas de remplacement, str_replace sera ses paramètres allouer de la mémoire. Très lent ! Solution :
Utilisez strpos pour rechercher d'abord (très rapidement) si un remplacement est nécessaire. Si nécessaire, remplacez à nouveau. Efficacité : - Si un remplacement est nécessaire : L'efficacité est presque égale et la différence est d'environ 0,1 %.
Si aucun remplacement n'est nécessaire : le strpos est 200 % plus rapide.

11. Le paramètre est une chaîne

Si une fonction peut accepter à la fois des tableaux et des caractères simples comme paramètres, comme une fonction de remplacement de caractères, et que la liste des paramètres n'est pas trop longue, vous pouvez envisagez d'écrire un morceau de code de remplacement supplémentaire afin que chaque paramètre passé soit un caractère, au lieu d'accepter des tableaux comme paramètres de recherche et de remplacement. Faites de grandes choses petites, 1+1>2;

12. Il est préférable de ne pas utiliser @, utiliser @ pour masquer les erreurs réduira la vitesse d'exécution du script ;

Utiliser @. implique en fait de nombreuses opérations en arrière-plan. La différence d'efficacité entre l'utilisation de @ et la non-utilisation de @ est : 3 fois. N'utilisez surtout pas @ dans une boucle. Dans le test de 5 boucles, même si vous utilisez error_reporting(0) pour désactiver d'abord l'erreur, puis l'activer une fois la boucle terminée, c'est plus rapide que d'utiliser @.

13.$row['id'] est 7 fois plus rapide que $row[id]

Il est recommandé de prendre l'habitude d'ajouter des guillemets aux clés du tableau ;

14. N'utilisez pas de fonctions

dans les boucles. Par exemple, For($x=0; $x 1897cde62992e035509b5b37f86acd8fprop++) est 3 fois plus lente qu'une variable locale ;

19 .La création d'une variable locale non déclarée est 9 à 10 fois plus lente qu'une variable locale définie

20. Déclarer une variable globale qui n'a été utilisée par aucune fonction réduira également les performances (et la déclaration du même nombre de variables locales. variables).

PHP peut vérifier si cette variable globale existe ;

21 La performance de la méthode n'a rien à voir avec le nombre de méthodes définies dans une classe

Parce que j'ai ajouté. 10 Il n'y a aucune différence de performances après l'ajout de plusieurs méthodes ou méthodes dans la classe testée (ces méthodes sont avant et après la méthode de test) ;

22. Les performances des méthodes dans les sous-classes sont meilleures que celles des classes de base. ;

23. Le temps nécessaire pour exécuter une fonction qui appelle un seul paramètre et a un corps de fonction vide est égal à 7-8 opérations $localvar++, alors qu'une méthode similaire (fonction dans une classe) s'exécute de manière égale. à environ 15 opérations $localvar++ ;

24 Utilisez des guillemets simples au lieu de guillemets doubles pour délimiter les chaînes, ce qui est plus rapide.

Parce que PHP recherchera des variables dans une chaîne entourée de guillemets doubles, mais pas de guillemets simples.

Le moteur PHP permet d'utiliser des guillemets simples et des guillemets doubles pour encapsuler des variables chaîne, mais il y a une grande différence ! L'utilisation d'une chaîne entre guillemets indique au moteur PHP de lire d'abord le contenu de la chaîne, d'y trouver les variables et de les remplacer par les valeurs correspondant aux variables. De manière générale, les chaînes n'ont pas de variables, donc l'utilisation de guillemets doubles entraînera de mauvaises performances. Il est préférable d'utiliser la concaténation de chaînes

au lieu de chaînes entre guillemets doubles.

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. Il est plus rapide d'utiliser des virgules au lieu de connecteurs de points lors de la mise en écho de chaînes.

echo est une "fonction" qui peut prendre plusieurs chaînes comme paramètres (Annotation : le manuel PHP dit que echo est une structure de langage, pas une vraie fonction, donc la fonction est placée entre guillemets doubles).

  例如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的扩展

Tout le monde s'est toujours plaint du fait que le contenu PHP était trop complexe. Ces dernières années, les développeurs ont fait des efforts correspondants pour supprimer certaines fonctionnalités redondantes du projet. Malgré tout, le nombre de bibliothèques et autres extensions disponibles est impressionnant. Certains développeurs commencent même à envisager d’implémenter leurs propres extensions.

5.Mise en cache PHP, utilisant l'accélérateur PHP : APC

Normalement, les scripts PHP sont compilés et exécutés par le moteur PHP et seront convertis en langage machine, également appelé tout comme le code d'opération. Si un script PHP obtient le même résultat après compilation encore et encore, pourquoi ne pas ignorer complètement le processus de compilation

Vous pouvez y parvenir via l'accélérateur PHP, qui met en cache le code machine du script PHP compilé ? code à exécuter immédiatement sur demande sans passer par un processus de compilation fastidieux.

Pour les développeurs PHP, il existe actuellement deux solutions de mise en cache disponibles. L'une est APC (Alternative PHP Cache, cache PHP facultatif), qui est un accélérateur open source qui peut être installé via PEAR. Une autre solution populaire est Zend Server, qui fournit non seulement une technologie de mise en cache des opcodes, mais fournit également des outils de mise en cache pour les pages correspondantes.

6. Cache mémoire

PHP joue généralement un rôle important dans la récupération et l'analyse des données, et ces opérations peuvent entraîner une dégradation des performances. En fait, certaines opérations sont totalement inutiles, notamment la récupération répétée de certaines données statiques couramment utilisées à partir de la base de données. Vous souhaiterez peut-être envisager d'utiliser l'extension Memcached pour mettre en cache les données à court terme. Le cache étendu de Memcached fonctionne avec la bibliothèque libMemcached pour mettre en cache les données dans la RAM et permet également aux utilisateurs de définir la période de cache, contribuant ainsi à garantir des mises à jour en temps réel des informations utilisateur.

7.Compression de contenu :

Presque tous les navigateurs prennent en charge la méthode de compression Gzip, gzip peut réduire la sortie de 80 %, payer le coût est une augmentation d'environ 10 % des calculs du processeur. Mais ce que vous gagnez, c'est que non seulement la bande passante occupée est réduite, mais que le chargement de vos pages deviendra plus rapide, optimisant ainsi les performances de votre site PHP.
Vous pouvez l'activer dans PHP.ini
zlib.output_compression = On
zlib.output_compression_level = (level) (le niveau peut être un nombre compris entre 1 et 9, vous pouvez définir différents nombres pour le rendre approprié pour votre site. )
Si vous utilisez Apache, vous pouvez également activer le module mod_gzip, qui est hautement personnalisable.

8. Cache serveur :

Principalement basé sur les serveurs statiques nginx et squid basés sur le proxy inverse web, ainsi que les modules mod_proxy et mod_cache d'apache2

9. Optimisation de la base de données : mise en cache de la base de données, etc.

En configurant le cache de la base de données, par exemple en activant le cache QueryCache, lorsque la requête reçoit une requête identique comme auparavant, le serveur le récupérera dans le cache des requêtes, au lieu de ré-analyser et d'exécuter la dernière requête
et les procédures de stockage des données, la technologie du pool de connexions, etc.

Recommandations associées :

Partage de conseils d'optimisation des performances PHP

Exemples détaillés d'optimisation des performances PHP

Cinq conseils d'optimisation des performances PHP

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!