Analyse détaillée du Code de performance de la fonction magique PHP-tutoriel php-php.cn

Je me souviens que frère Laruence a mentionné un jour qu'il n'était pas recommandé d'utiliser des « méthodes magiques ». Depuis, chaque fois que des méthodes magiques sont impliquées, j'y réfléchirai inconsciemment, est-ce une bonne façon de prendre des photos ? 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 un état second. Cette année est pour moi une année pour étudier en profondeur. , alors maintenant je dois faire quelques recherches sur cette question. Le problème est réglé. Jetons d'abord un coup d'œil à ce que Bird Brother Laruence a mentionné un jour sur son blog :

Lorsque je partage le PPT avec mes collègues de l'entreprise, certaines personnes se demanderont si même les méthodes magiques ne sont pas autorisées à être utilisé ?

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

Doute

La méthode magique est-elle vraiment peu performante ?
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 :

Comparaison statistique entre utiliser la méthode magique et ne pas l'utiliser it La différence de temps d'exécution du script de la méthode magique
Le script est exécuté en continu n fois sous PHP5.6.26-1
La moyenne /temps d'exécution statistique minimum Valeur/valeur maximum
Exécuter en continu le script n fois sous PHP7.0.12-2
Statistiques sur la moyenne/ temps d'exécution minimum/maximum Valeur

Actuellement, mes capacités personnelles sont limitées et je ne peux utiliser cette méthode que si vous avez un meilleur plan ou une meilleure suggestion, vous pouvez me le dire, merci, haha. ~

Test

__construct

Tout d'abord, jetons un œil à l'expérience du constructeur __construct Le script php est le suivant :

<?php
/**
 * 魔术方法性能探索
 *
 * 构造函数
 *
 * @author TIGERB <//m.sbmmt.com/;
 */

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";

Copier après la connexion

<. 🎜>

PHP5.6 n'utilise pas la magie Les données de la méthode sont les suivantes, l'unité est la microseconde μ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

Copier après la connexion

PHP5. 6 utilise les données de la méthode magique comme suit, l'unité est la microseconde μm

// PHP5.6中连续调用脚本10000次
sh test 10000 magic php5 construct

// 运行数据统计脚本
sh analysis ./logs/__construct_magic_php5.log 10000

// 结果
avg: 28μm
max: 896μm
min: 20μm

Copier après la connexion

PHP7.0 n'utilise pas la méthode magique. , en microsecondes μm

// PHP7.0中连续调用脚本10000次
sh test 10000 no_magic php construct

// 运行数据统计脚本
sh analysis ./logs/__construct_no_magic_php.log 10000

// 结果
avg: 19μm
max: 819μm
min: 13μm

Copier après la connexion

PHP7 0 Les données utilisant la méthode magique sont les suivantes, en microsecondes μm

// PHP7.0中连续调用脚本10000次
sh test 10000 magic php construct

// 运行数据统计脚本
sh analysis ./logs/__construct_magic_php.log 10000

// 结果
avg: 14μm
max: 157μm
min: 10μm

Copier après la connexion

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

Utiliser __construct comme constructeur pour l'exécution du script Le temps moyen est plus rapide que d'utiliser le nom de la classe comme constructeur,

environ 5 à 6 microsecondes , que ce soit en php5.6 ou php7.0.

__call

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

<?php
/**
 * 魔术方法性能探索
 *
 * 构造函数
 *
 * @author TIGERB <//m.sbmmt.com/;
 */

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";

Copier après la connexion

PHP5.6 le fait. ne pas utiliser de méthodes magiques Les données sont les suivantes, l'unité est la microseconde μ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

Copier après la connexion

PHP5.6 utilise la méthode magique. 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μm
max: 392μm
min: 22μm

Copier après la connexion

PHP7.0 n'utilise pas la méthode magique Les données sont les suivantes, en microsecondes μm
<🎜. >

// PHP7.0中连续调用脚本10000次
sh test 10000 no_magic php call

// 运行数据统计脚本
sh analysis ./logs/__call_no_magic_php.log 10000

// 结果
avg: 16μm
max: 256μm
min: 10μm

Copier après la connexion

D'après ce qui précède données que nous pouvons voir :

// PHP7.0中连续调用脚本10000次
sh test 10000 magic php call

// 运行数据统计脚本
sh analysis ./logs/__call_magic_php.log 10000

// 结果
avg: 18μm
max: 2459μm
min: 11μm

Copier après la connexion

Le temps d'exécution moyen d'un script utilisant __call est plus lent que de ne pas l'utiliser,

environ 2 microsecondes

, à la fois en php5.6 et en php7.0. __callStatic

Ensuite, jetons un coup d'œil à l'expérience __callStatic

<?php
/**
 * 魔术方法性能探索
 *
 * 静态重载函数
 *
 * @author TIGERB <//m.sbmmt.com/;
 */

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";

Copier après la connexion

// 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

Copier après la connexion

// PHP5.6中连续调用脚本10000次
sh test 10000 magic php5 callStatic

// 运行数据统计脚本
sh analysis ./logs/__callStatic_magic_php5.log 10000

// 结果
avg: 28μm
max: 580μm
min: 20μm

Copier après la connexion

<🎜. >

// PHP7.0中连续调用脚本10000次
sh test 10000 no_magic php callStatic

// 运行数据统计脚本
sh analysis ./logs/__callStatic_no_magic_php.log 10000

// 结果
avg: 14μm
max: 130μm
min: 9μm

Copier après la connexion

PHP7.0 Les données utilisant la méthode magique sont les suivantes, en microsecondes μm

// PHP7.0中连续调用脚本10000次
sh test 10000 magic php callStatic

// 运行数据统计脚本
sh analysis ./logs/__callStatic_magic_php.log 10000

// 结果
avg: 14μm
max: 159μm
min: 10μm

Copier après la connexion

Utiliser le script __callStatic en php5.6 Le temps d'exécution moyen est plus lent que de ne pas l'utiliser,

environ 3 microsecondes

; 0 équivaut à peu près à ne pas utiliser __callStatic ;

__set

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

<. 🎜>

PHP5.6 n'utilise pas la méthode magique. Les données sont les suivantes, L'unité microseconde μm

<?php
/**
 * 魔术方法性能探索
 *
 * 设置私有属性__set
 *
 * @author TIGERB <//m.sbmmt.com/;
 */

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";

Copier après la connexion

PHP5.6 utilise les données de la méthode magique comme suit, l'unité microseconde μ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

Copier après la connexion

PHP7.0 n'utilise pas la méthode magique. Les données sont les suivantes, en microsecondes. μm

// PHP5.6中连续调用脚本10000次
sh test 10000 magic php5 set
// 运行数据统计脚本
sh analysis ./logs/__set_magic_php5.log 10000

// 结果
avg: 33μm
max: 138μm
min: 25μm

Copier après la connexion

PHP7.0 utilise la méthode magique Les données sont les suivantes, en microsecondes μm

// PHP7.0中连续调用脚本10000次
sh test 10000 no_magic php set
// 运行数据统计脚本
sh analysis ./logs/__set_no_magic_php.log 10000

// 结果
avg: 15μm
max: 441μm
min: 11μm

Copier après la connexion

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

Le temps d'exécution moyen des scripts utilisant __set est plus lent que sans cela,

// PHP7.0中连续调用脚本10000次
sh test 10000 magic php set
// 运行数据统计脚本
sh analysis ./logs/__set_magic_php.log 10000

// 结果
avg: 17μm
max: 120μm
min: 11μm

Copier après la connexion

environ 2 microsecondes plus lent

, que ce soit en php5.6 ou php7. 0.

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

<?php
/**
 * 魔术方法性能探索
 *
 * 读取私有属性__get
 *
 * @author TIGERB <//m.sbmmt.com/;
 */

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";

Copier après la connexion

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

Copier après la connexion

PHP5.6使用魔术方法数据如下，单位微秒μm

// PHP5.6中连续调用脚本10000次
sh test 10000 magic php5 get
// 运行数据统计脚本
sh analysis ./logs/__get_magic_php5.log 10000

// 结果
avg: 28μm
max: 211μm
min: 22μm

Copier après la connexion

PHP7.0不使用魔术方法数据如下，单位微秒μm

// PHP7.0中连续调用脚本10000次
sh test 10000 no_magic php get
// 运行数据统计脚本
sh analysis ./logs/__get_no_magic_php.log 10000

// 结果
avg: 16μm
max: 295μm
min: 10μm

Copier après la connexion

PHP7.0使用魔术方法数据如下，单位微秒μm

// PHP7.0中连续调用脚本10000次
sh test 10000 magic php get
// 运行数据统计脚本
sh analysis ./logs/__get_magic_php.log 10000

// 结果
avg: 19μm
max: 525μm
min: 12μm

Copier après la connexion

通过上面的数据我们可以看出：

在php5.6中使用__get的脚本执行的平均时间是要大致等于不使用__get的;在php7.0中使用__get的脚本执行的平均时间是要慢于不使用， 大概慢3微秒 。

结语

这里主要测试了__construct()， __call()， __callStatic()， __get()， __set()这五个常用的且可有其他实现方式代替的魔法函数。通过上面的测试再回来解答我的疑惑

魔术方法真的性能比较差吗？

答：除了使用__construct之外，这里使用其他的魔法方法的时间大致慢10微妙以内。

PHP7里使用魔术方法的性能还是存在问题吗？

答：在PHP7中使用与不使用魔术方法之间的差异和在PHP5.6中近乎一致。

我们应该如何合理的使用魔术方法？

答：通过整个测试我们可以看出使不使用魔法方法这之间的执行时间差异大致都是在10微妙以内的，所以如果魔法方法可以很好的节省我们的开发成本和优化我们的代码结构，我们应该可以考虑牺牲掉这不到10微妙。而__construct是要快的，所以使用__construct应该没什么异议。

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!