Teilen von Beispielen für die magische Methode der PHP-Leistungsanalyse

Ich habe mich einmal daran erinnert, dass Bird Brother Laruence erwähnt hat, dass es nicht empfehlenswert ist, „magische Methoden“ anzuwenden. Seitdem werden Blogger unbewusst darüber nachdenken ein gutes Foto? Da ich in den letzten zwei Jahren mit der Arbeit und dem Erlernen neuer Kenntnisse beschäftigt war, habe ich mich auf diesem Weg nicht eingehend erkundet und war benommen. Dieses Jahr ist ein Jahr für Blogger, in dem es darum geht, eingehend zu studieren , also muss ich jetzt. Dieses Problem ist geklärt. Schauen wir uns zunächst an, was Bird Brother Laruence einmal in seinem Blog erwähnt hat:

Optimierungsvorschläge sind Vorschläge, um zu verhindern, dass Menschen sie missbrauchen und skrupellos verwenden, wenn Sie beim Schreiben von Code erkennen können, was langsam und was schnell ist , um unnötige Aufrufe magischer Methoden zu vermeiden, das ist der Effekt, den dieser Optimierungsvorschlag verfolgt

Zweifel

Ist die Leistung magischer Methoden wirklich schlecht?
Gibt es immer noch ein Problem mit der Leistung magischer Methoden in PHP7?
Wie sollten wir magische Methoden sinnvoll einsetzen?

Plan

Trotz meiner Zweifel ist mein Plan:

Statistisch den Zeitunterschied zwischen der Skriptausführung mit der magischen Methode und der Nichtverwendung der magischen Methode vergleichen
PHP5. 1 Führen Sie das Skript n-mal kontinuierlich unter PHP 7.0.12-2 aus
Zählen Sie die durchschnittliche/minimale/maximale Ausführungszeit/Maximum
Derzeit sind meine persönlichen Fähigkeiten begrenzt und ich kann diese Methode nur verwenden, wenn Sie eine bessere haben Plan oder Vorschlag, bitte sag es mir, danke, haha~

Test

__construct

Werfen wir zunächst einen Blick auf das Experiment der Konstruktorfunktion __construct. Das PHP-Skript lautet wie folgt:

Die magischen Methodendaten für PHP5.6 lauten wie folgt, in Mikrosekunden μ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 Rufen Sie das Skript kontinuierlich 10.000 Mal auf

PHP7.0 verwendet nicht die magische Methode, die Daten sind wie folgt, die Einheit ist Mikrosekunde μm

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

PHP7.0 verwendet die magische Methode, die Daten sind wie folgt, die Einheit Mikrosekunde μ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

// Rufen Sie das Skript kontinuierlich 10.000 Mal in PHP7.0 auf

Aus den obigen Daten können wir Folgendes sehen:

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

Skriptausführung mit __construct als Konstruktor Die durchschnittliche Zeit ist schneller als die Verwendung des Klassennamens als Konstruktor, etwa 5 bis 6 Mikrosekunden schneller, sowohl in PHP5.6 als auch in PHP7.0.

__call

Als nächstes schauen wir uns das __call-Experiment an:

PHP5.6 verwendet die magische Methode Die Daten ist wie folgt, in Mikrosekunden μ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 verwendet nicht die magische Methode. Die Daten sind wie folgt, die Einheit ist Mikrosekunden μ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 verwendet Die magische Methode lautet wie folgt, die Einheit ist Mikrosekunde μ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

Aus den obigen Daten können wir ersehen:

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

Die durchschnittliche Ausführungszeit von Skripten, die __call verwenden, ist langsamer ohne es zu verwenden, etwa 2 Mikrosekunden langsamer, egal ob in PHP5.6 oder PHP7 0 Treffer.

__callStatic

Als nächstes schauen wir uns das Experiment von __callStatic an:

PHP5.6 verwendet die magische Methode Die Daten sind wie folgt, in Mikrosekunden μ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 verwendet nicht die magische Methode. Die Daten sind wie folgt, die Einheit ist Mikrosekunden μ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 verwendet die magische Methode. Die Daten sind wie folgt, die Einheit ist Mikrosekunde μ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

Wir können aus den obigen Daten sehen:

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

Die durchschnittliche Ausführungszeit von Skripten, die __callStatic in PHP5 verwenden. 6 ist langsamer als ohne, in PHP7.0 etwa 3 Mikrosekunden. Die durchschnittliche Ausführungszeit eines Skripts mit __callStatic entspricht in etwa der ohne __callStatic Schauen Sie sich das __set-Experiment an:

PHP5.6 verwendet die Daten der magischen Methode wie folgt, in Mikrosekunden μm

Wir können aus dem sehen obige Daten:

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

Verwenden Sie die Ausführung des __set-Skripts. Die durchschnittliche Zeit ist langsamer als bei Nichtverwendung, etwa 2 Mikrosekunden langsamer, sowohl in PHP5.6 als auch in PHP7.0.

__get

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

Als nächstes schauen wir uns das Experiment von __get an:

PHP5.6 verwendet die magische Methode Die Daten sind wie folgt, in Mikrosekunden μm

PHP7.0 verwendet nicht die magische Methode. Die Daten sind wie folgt, die Einheit ist Mikrosekunden μ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 verwendet die magische Methode. Die Daten sind wie folgt, die Einheit ist Mikrosekunde μ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

Wir können aus den obigen Daten sehen:

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

Die durchschnittliche Ausführungszeit eines Skripts mit __get in PHP5 .6 entspricht in etwa dem ohne __get; bei Verwendung von _ in php7.0 ist die durchschnittliche Ausführungszeit des _get-Skripts langsamer als ohne, etwa 3 Mikrosekunden langsamer.

Fazit

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

Hier haben wir hauptsächlich __construct(), __call(), __callStatic(), __get(), __set() getestet, die häufig verwendet werden und durch andere Implementierungsmethoden ersetzt werden können Funktion. Nachdem ich den obigen Test bestanden habe, werde ich zurückkommen, um meine Fragen zu beantworten

Ist die Leistung der magischen Methode wirklich schlecht?

A: Zusätzlich zur Verwendung von __construct beträgt die Zeit für die Verwendung anderer magischer Methoden hier etwa 10 Mikrosekunden.

Gibt es immer noch ein Problem mit der Leistung bei der Verwendung magischer Methoden in PHP7?

A: Der Unterschied zwischen der Verwendung und Nichtverwendung magischer Methoden in PHP7 ist fast der gleiche wie in PHP5.6.

Wie sollten wir magische Methoden sinnvoll einsetzen?

A: Während des gesamten Tests können wir sehen, dass der Ausführungszeitunterschied zwischen der Nichtverwendung der magischen Methode ungefähr innerhalb von 10 Mikrosekunden liegt. Wenn die magische Methode also unsere Entwicklungskosten einsparen und unsere Codestruktur optimieren kann, Wir sollten darüber nachdenken, weniger als 10 Mikrosekunden zu opfern. __construct soll schnell sein, daher sollte es keine Einwände gegen die Verwendung von __construct geben.

Ich habe mich einmal daran erinnert, dass Bruder Laruence erwähnt hat, dass die Verwendung „magischer Methoden“ nicht empfohlen wird. Seitdem denken Blogger unbewusst darüber nach, ob das ein gutes Foto ist. Da ich in den letzten zwei Jahren mit der Arbeit und dem Erlernen neuer Kenntnisse beschäftigt war, habe ich mich nicht eingehend mit dieser Hürde befasst und war benommen. Dieses Jahr ist für Blogger ein Jahr, in dem sie sich eingehend damit befassen , also muss ich jetzt. Dieses Problem ist geklärt. Werfen wir zunächst einen Blick auf das, was Bird Brother Laruence einmal in seinem Blog erwähnt hat:

Optimierungsvorschläge sind Vorschläge, um zu verhindern, dass Menschen sie missbrauchen und skrupellos verwenden. Wenn Sie beim Schreiben von Code erkennen können, was langsam ist, was ist schnell, um unnötige Aufrufe magischer Methoden zu vermeiden, das ist der Effekt, den dieser Optimierungsvorschlag verfolgt

Das obige ist der detaillierte Inhalt vonTeilen von Beispielen für die magische Methode der PHP-Leistungsanalyse. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!