Partage d'exemples de méthodes magiques d'analyse des performances PHP

Je me suis souvenu un jour que Bird Brother Laruence avait mentionné qu'il n'était pas recommandé d'utiliser des "méthodes magiques". Depuis lors, chaque fois que des méthodes magiques sont utilisées, les blogueurs y penseront inconsciemment. une bonne photo ? Depuis que j'ai été occupé par le travail et l'apprentissage de nouvelles connaissances au cours des deux dernières années, je n'ai fait aucune exploration approfondie sur cette route et j'ai été dans le vertige. Cette année est une année pour les blogueurs pour mener des études approfondies. , alors maintenant je dois. Ce problème est réglé. Jetons d'abord un coup d'œil à ce que Bird Brother Laruence a mentionné un jour sur son blog :

Les suggestions d'optimisation sont des suggestions pour empêcher les gens d'en abuser et de les utiliser sans scrupules. Si vous pouvez réaliser lors de l'écriture du code, ce qui est lent, ce qui est rapide. , afin d'éviter les appels inutiles aux méthodes magiques, tel est l'effet recherché par cette suggestion d'optimisation

Doute

Les performances des méthodes magiques sont-elles vraiment mauvaises ?
Y a-t-il toujours un problème avec les performances des méthodes magiques en PHP7 ?
Comment devrions-nous utiliser les méthodes magiques de manière raisonnable ?

Plan

Face à mes doutes, mon plan est le suivant :

Comparer statistiquement le décalage horaire entre l'exécution du script en utilisant la méthode magique et sans utiliser la méthode magique
PHP5 6.26-. 1 Exécutez le script n fois en continu sous PHP 7.0.12-2
Comptez le temps d'exécution moyen/minimum/maximum /Maximum
Actuellement, mes capacités personnelles sont limitées et je ne peux utiliser cette méthode que si vous avez une meilleure. plan ou suggestion, dites-moi s'il vous plaît, merci, haha~

Test

__construct

Tout d'abord, jetons un coup d'œil à l'expérience de la fonction constructeur __construct. Le script PHP est le suivant :

Les données de la méthode magique pour PHP5.6 sont les suivantes, en microsecondes μm

<?php/**
 * 魔术方法性能探索
 *
 * 构造函数
 *
 * @author TIGERB <https://github.com/TIGERB>
 */require(&#39;./function.php&#39;);if (!isset($argv[1])) {
    die(&#39;error: variable is_use_magic is empty&#39;);
}
$is_use_magic = $argv[1];/**
 * 构造函数使用类名
 */class ClassOne
{    public function classOne()
    {
        # code...
    }
}/**
 * 构造函数使用魔术函数__construct
 */class ClassTwo
{    public function __construct()
    {
        # code...
    }
}

$a = getmicrotime();if ($is_use_magic === &#39;no_magic&#39;) {    new ClassOne();
}else {    new ClassTwo();
}
$b = getmicrotime();

echo  ($b-$a) . "\n";
PHP5.6不使用魔术方法数据如下，单位微秒μm// PHP5.6中连续调用脚本10000次sh test 10000 no_magic php5 construct// 运行数据统计脚本sh analysis ./logs/__construct_no_magic_php5.log 10000// 结果avg: 34μm
max: 483μm
min: 26μm

// PHP5 .6 Appelez le script en continu 10 000 fois

PHP7.0 n'utilise pas la méthode magique, les données sont les suivantes, l'unité est la microseconde μm

sh test 10000 magic php5 construct// 运行数据统计脚本sh analysis ./logs/__construct_magic_php5.log 10000// 结果avg: 28μmmax: 896μmmin: 20μm

PHP7.0 utilise la méthode magique, les données sont les suivantes, l'unité Microseconde μm

// PHP7.0中连续调用脚本10000次sh test 10000 no_magic php construct// 运行数据统计脚本sh analysis ./logs/__construct_no_magic_php.log 10000// 结果avg: 19μmmax: 819μmmin: 13μm

// Appeler le script en continu 10 000 fois en PHP7.0

À partir des données ci-dessus, nous pouvons voir :

sh test 10000 magic php construct// 运行数据统计脚本sh analysis ./logs/__construct_magic_php.log 10000// 结果avg: 14μmmax: 157μmmin: 10μm

Exécution du script en utilisant __construct comme constructeur Le temps moyen est plus rapide que d'utiliser le nom de la classe comme constructeur, environ 5 à 6 microsecondes plus rapide, à la fois en php5.6 et en php7.0.

__call

Ensuite, jetons un coup d'œil à l'expérience __call. Le script PHP est le suivant :

PHP5.6 utilise la méthode magique. est la suivante, en microsecondes μm

<?php/**
 * 魔术方法性能探索
 *
 * 构造函数
 *
 * @author TIGERB <https://github.com/TIGERB>
 */require(&#39;./function.php&#39;);if (!isset($argv[1])) {    die(&#39;error: variable is_use_magic is empty&#39;);
}$is_use_magic = $argv[1];/**
 * 构造函数使用类名
 */class ClassOne{
    public function __construct()
    {
        # code...
    }    public function test()
    {
        # code...
    }
}/**
 * 构造函数使用魔术函数__construct
 */class ClassTwo{
    public function __construct()
    {
        # code...
    }    public function __call($method, $argus)
    {
        # code...
    }
}$a = getmicrotime();if ($is_use_magic === &#39;no_magic&#39;) {    $instance = new ClassOne();    $instance->test();
}else {    $instance = new ClassTwo();    $instance->test();
}$b = getmicrotime();echo  ($b-$a) . "\n";
PHP5.6不使用魔术方法数据如下，单位微秒μm// PHP5.6中连续调用脚本10000次sh test 10000 no_magic php5 call// 运行数据统计脚本sh analysis ./logs/__call_no_magic_php5.log 10000// 结果avg: 27μm
max: 206μm
min: 20μm

PHP7.0 n'utilise pas la méthode magique. Les données sont les suivantes, l'unité est la microseconde μm

// PHP5.6中连续调用脚本10000次sh test 10000 magic php5 call// 运行数据统计脚本sh analysis ./logs/__call_magic_php5.log 10000// 结果avg: 29μmmax: 392μmmin: 22μm

PHP7.0. utilise la méthode magique. Les données sont les suivantes, l'unité est la microseconde μm

// PHP7.0中连续调用脚本10000次sh test 10000 no_magic php call// 运行数据统计脚本sh analysis ./logs/__call_no_magic_php.log 10000// 结果avg: 16μmmax: 256μmmin: 10μm

Nous pouvons voir à partir des données ci-dessus :

// PHP7.0中连续调用脚本10000次sh test 10000 magic php call// 运行数据统计脚本sh analysis ./logs/__call_magic_php.log 10000// 结果avg: 18μmmax: 2459μmmin: 11μm

Le temps d'exécution moyen des scripts utilisant __call est plus lent que que sans l'utiliser, environ 2 microsecondes plus lentement, que ce soit en php5.6 ou php7 0 hits.

__callStatic

Ensuite, jetons un coup d'œil à l'expérience de __callStatic. Le script PHP est le suivant :

PHP5.6 utilise la méthode magique. les données sont les suivantes, en microsecondes μm

<?php/**
 * 魔术方法性能探索
 *
 * 静态重载函数
 *
 * @author TIGERB <https://github.com/TIGERB>
 */require(&#39;./function.php&#39;);if (!isset($argv[1])) {    die(&#39;error: variable is_use_magic is empty&#39;);
}$is_use_magic = $argv[1];/**
 * 存在test静态方法
 */class ClassOne{
    public function __construct()
    {
        # code...
    }    public static function test()
    {
        # code...
    }
}/**
 * 使用重载实现test
 */class ClassTwo{
    public function __construct()
    {
        # code...
    }    public static function __callStatic($method, $argus)
    {
        # code...
    }
}$a = getmicrotime();if ($is_use_magic === &#39;no_magic&#39;) {
    ClassOne::test();
}else {
    ClassTwo::test();
}$b = getmicrotime();echo  ($b-$a) . "\n";
PHP5.6不使用魔术方法数据如下，单位微秒μm// PHP5.6中连续调用脚本10000次sh test 10000 no_magic php5 callStatic// 运行数据统计脚本sh analysis ./logs/__callStatic_no_magic_php5.log 10000// 结果avg: 25μm
max: 129μm
min: 19μm

PHP7.0 n'utilise pas la méthode magique Les données sont les suivantes, l'unité est la microseconde μm

// PHP5.6中连续调用脚本10000次sh test 10000 magic php5 callStatic// 运行数据统计脚本sh analysis ./logs/__callStatic_magic_php5.log 10000// 结果avg: 28μmmax: 580μmmin: 20μm

PHP7.0. utilise la méthode magique. Les données sont les suivantes, l'unité est la microseconde μm

// PHP7.0中连续调用脚本10000次sh test 10000 no_magic php callStatic// 运行数据统计脚本sh analysis ./logs/__callStatic_no_magic_php.log 10000// 结果avg: 14μmmax: 130μmmin: 9μm

Nous pouvons voir à partir des données ci-dessus :

// PHP7.0中连续调用脚本10000次sh test 10000 magic php callStatic// 运行数据统计脚本sh analysis ./logs/__callStatic_magic_php.log 10000// 结果avg: 14μmmax: 159μmmin: 10μm

Le temps d'exécution moyen des scripts utilisant __callStatic en php5. 6 est plus lent que sans, environ 3 microsecondes ; dans php7.0, le temps d'exécution moyen d'un script utilisant __callStatic est à peu près égal à celui sans __callStatic

__set

Ensuite, prenons un regardez l'expérience __set. Le script PHP est le suivant :

PHP5.6 utilise les données de la méthode magique comme suit, en microsecondes μm

<?php
/**
 * 魔术方法性能探索
 *
 * 设置私有属性__set
 *
 * @author TIGERB <https://github.com/TIGERB>
 */require(&#39;./function.php&#39;);if (!isset($argv[1])) {
    die(&#39;error: variable is_use_magic is empty&#39;);
}
$is_use_magic = $argv[1];/**
 * 实现公共方法设置私有属性
 */class ClassOne
{    /**
     * 私有属性
     *
     * @var string
     */
    private $someVariable = &#39;private&#39;;    public function __construct()
    {
        # code...
    }    public function setSomeVariable($value = &#39;&#39;)
    {
        $this->someVariable = $value;
    }
}/**
 * 使用_set设置私有属性
 */class ClassTwo
{    /**
     * 私有属性
     *
     * @var string
     */
    private $someVariable = &#39;private&#39;;    public function __construct()
    {
        # code...
    }    public function __set($name = &#39;&#39;, $value = &#39;&#39;)
    {
        $this->$name = $value;
    }
}

$a = getmicrotime();if ($is_use_magic === &#39;no_magic&#39;) {
    $instance = new ClassOne();
    $instance->setSomeVariable(&#39;public&#39;);
}else {
    $instance = new ClassTwo();
    $instance->someVariable = &#39;public&#39;;
}
$b = getmicrotime();

echo  ($b-$a) . "\n";
PHP5.6不使用魔术方法数据如下，单位微秒μm// PHP5.6中连续调用脚本10000次sh test 10000 no_magic php5 set// 运行数据统计脚本sh analysis ./logs/__set_no_magic_php5.log 10000// 结果avg: 31μm
max: 110μm
min: 24μm

Nous pouvons le voir sur le données ci-dessus :

// PHP5.6中连续调用脚本10000次
sh test 10000 magic php5 set// 运行数据统计脚本sh analysis ./logs/__set_magic_php5.log 10000// 结果avg: 33μmmax: 138μmmin: 25μm
PHP7.0不使用魔术方法数据如下，单位微秒μm// PHP7.0中连续调用脚本10000次sh test 10000 no_magic php set// 运行数据统计脚本sh analysis ./logs/__set_no_magic_php.log 10000// 结果avg: 15μmmax: 441μmmin: 11μm
PHP7.0使用魔术方法数据如下，单位微秒μm// PHP7.0中连续调用脚本10000次sh test 10000 magic php set// 运行数据统计脚本sh analysis ./logs/__set_magic_php.log 10000// 结果avg: 17μmmax: 120μmmin: 11μm

Utiliser l'exécution du script __set Le temps moyen est plus lent que de ne pas l'utiliser, environ 2 microsecondes plus lent, à la fois en php5.6 et en php7.0.

__get

Ensuite, jetons un coup d'œil à l'expérience de __get. Le script PHP est le suivant :

PHP5.6 utilise la méthode magique. les données sont les suivantes, en microsecondes μm

<?php/**
 * 魔术方法性能探索
 *
 * 读取私有属性__get
 *
 * @author TIGERB <https://github.com/TIGERB>
 */require(&#39;./function.php&#39;);if (!isset($argv[1])) {
    die(&#39;error: variable is_use_magic is empty&#39;);
}
$is_use_magic = $argv[1];/**
 * 实现公共方法获取私有属性
 */class ClassOne
{    /**
     * 私有属性
     *
     * @var string
     */
    private $someVariable = &#39;private&#39;;    public function __construct()
    {
        # code...
    }    public function getSomeVariable()
    {        return $this->someVariable;
    }
}/**
 * 使用_get获取私有属性
 */class ClassTwo
{    /**
     * 私有属性
     *
     * @var string
     */
    private $someVariable = &#39;private&#39;;    public function __construct()
    {
        # code...
    }    public function __get($name = &#39;&#39;)
    {        return $this->$name;
    }
}

$a = getmicrotime();if ($is_use_magic === &#39;no_magic&#39;) {
    $instance = new ClassOne();
    $instance->getSomeVariable();
}else {
    $instance = new ClassTwo();
    $instance->someVariable;
}
$b = getmicrotime();

echo  ($b-$a) . "\n";
PHP5.6不使用魔术方法数据如下，单位微秒μm// PHP5.6中连续调用脚本10000次sh test 10000 no_magic php5 get// 运行数据统计脚本sh analysis ./logs/__get_no_magic_php5.log 10000// 结果avg: 28μm
max: 590μm
min: 20μm

PHP7.0 n'utilise pas la méthode magique Les données sont les suivantes, l'unité est la microseconde μm

// PHP5.6中连续调用脚本10000次
sh test 10000 magic php5 get// 运行数据统计脚本sh analysis ./logs/__get_magic_php5.log 10000// 结果avg: 28μmmax: 211μmmin: 22μm

PHP7.0. utilise la méthode magique. Les données sont les suivantes, l'unité est la microseconde μm

// PHP7.0中连续调用脚本10000次
sh test 10000 no_magic php get// 运行数据统计脚本sh analysis ./logs/__get_no_magic_php.log 10000// 结果avg: 16μmmax: 295μmmin: 10μm

Nous pouvons voir à partir des données ci-dessus :

// PHP7.0中连续调用脚本10000次
sh test 10000 magic php get// 运行数据统计脚本sh analysis ./logs/__get_magic_php.log 10000// 结果avg: 19μmmax: 525μmmin: 12μm

Le temps d'exécution moyen d'un script utilisant __get en php5. .6 est à peu près égal à celui sans __get ; en utilisant _ dans php7.0 Le temps d'exécution moyen du script _get est plus lent que sans lui, environ 3 microsecondes plus lent.

Conclusion

Ici, nous avons principalement testé __construct(), __call(), __callStatic(), __get(), __set() qui sont couramment utilisés et peuvent être remplacés par d'autres méthodes d'implémentation de Magic. fonction. Après avoir réussi le test ci-dessus, je reviendrai répondre à mes questions

Les performances de la méthode magique sont-elles vraiment médiocres ?

R : En plus d'utiliser __construct, le temps d'utilisation d'autres méthodes magiques ici est d'environ 10 microsecondes.

Y a-t-il toujours un problème avec les performances d'utilisation des méthodes magiques en PHP7 ?

R : La différence entre utiliser et ne pas utiliser les méthodes magiques en PHP7 est presque la même qu'en PHP5.6.

Comment devrions-nous utiliser les méthodes magiques de manière raisonnable ?

R : Tout au long du test, nous pouvons voir que la différence de temps d'exécution entre la non-utilisation de la méthode magique est d'environ 10 microsecondes, donc si la méthode magique peut économiser nos coûts de développement et optimiser notre structure de code, nous devrions envisager de sacrifier moins de 10 microsecondes. __construct est censé être rapide, il ne devrait donc y avoir aucune objection à utiliser __construct.

Je me suis souvenu un jour que frère Laruence avait mentionné qu'il n'était pas recommandé d'utiliser des "méthodes magiques". Depuis, chaque fois que des méthodes magiques sont impliquées, les blogueurs y réfléchissent inconsciemment, est-ce une bonne photo ? Depuis que j'ai été occupé par le travail et l'apprentissage de nouvelles connaissances au cours des deux dernières années, je n'ai fait aucune exploration approfondie sur cette route et j'ai été dans le vertige. Cette année est une année pour les blogueurs pour mener des études approfondies. , alors maintenant je dois. Ce problème est réglé. Jetons d'abord un coup d'œil à ce que Bird Brother Laruence a mentionné un jour sur son blog :

Les suggestions d'optimisation sont des suggestions pour empêcher les gens d'en abuser et de les utiliser sans scrupules. Si vous pouvez réaliser lors de l'écriture du code, ce qui est lent, quoi. est rapide, afin d'éviter les appels inutiles à des méthodes magiques, c'est l'effet recherché par cette suggestion d'optimisation

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!