Heim > Artikel > Backend-Entwicklung > Beispielcode, der die Leistung von PHP-Magic-Funktionen im Detail erklärt

Beispielcode, der die Leistung von PHP-Magic-Funktionen im Detail erklärt

黄舟Original: 2017-03-13 16:37:561549Durchsuche

Ich erinnerte mich einmal daran, dass Bruder Laruence erwähnte, dass die Verwendung von „Magischen Methoden“ nicht empfohlen wurde. Von da an dachte ich unbewusst darüber nach, ob dies ein guter Weg sei um Fotos zu machen? Da ich in den letzten ein bis 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 für mich ein Jahr zum intensiven Lernen , also muss ich jetzt etwas zu diesem Thema recherchieren. Das Problem ist gelöst. Werfen wir zunächst einen Blick auf das, was Bird Brother Laruence einmal in seinem Blog erwähnt hat:

Wenn ich die PPT mit meinen Kollegen im Unternehmen teile, fragen sich einige Leute, dass nicht einmal die magische Methode erlaubt ist?

Optimierung Der Vorschlag ist ein Vorschlag, um zu verhindern, dass Menschen ihn 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, ist dies eine Optimierung empfohlen, um den gewünschten Effekt zu erzielen

Verwirrt

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

Plan

Angesichts meiner Zweifel lautet mein Plan:

Statistischer Vergleich zwischen der Anwendung der magischen Methode und der Nichtanwendung it Der Zeitunterschied bei der Ausführung von Magic-Methode-Skripten
Das Skript wird kontinuierlich n-mal unter PHP5.6.26-1 ausgeführt
Der Durchschnitt/Minimum statistischer Ausführungszeitwert/Maximalwert
Führen Sie das Skript kontinuierlich n-mal unter PHP7.0.12-2 aus
Statistik im Durchschnitt/Minimum/ Maximaler Ausführungszeitwert

Derzeit sind meine persönlichen Fähigkeiten begrenzt und ich kann diese Methode nur verwenden. Wenn Sie einen besseren Plan oder Vorschlag haben, können Sie es mir sagen, danke, haha~

Test

construct

Werfen wir zunächst einen Blick auf das Experiment von Constructorconstruct. Das PHP-Skript lautet wie folgt:

<?php
/**
 * 魔术方法性能探索
 *
 * 构造函数
 *
 * @author TIGERB <http://www.php.cn/;
 */

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 Die Daten ohne magische Methode lauten wie folgt, die Einheit ist Mikrosekunde μ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 Die Daten, die die magische Methode verwenden, lauten wie folgt, die Einheit ist Mikrosekunde μ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

PHP7.0 verwendet keine Daten der magischen Methode wie folgt: in Mikrosekunden μ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

PHP7.0 verwendet die Daten der magischen Methode wie folgt, in Mikrosekunden μ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

Aus den obigen Daten können wir ersehen:

Konstrukt als Konstruktor verwenden. Die durchschnittliche Skriptausführungszeit der Funktion ist schneller als die Verwendung des Klassennamens als Konstruktor, ungefähr 5 bis 6 Mikrosekunden schneller, egal ob in PHP5.6 oder PHP7.0.

Aufruf

Als nächstes werfen wir einen Blick auf das Aufrufexperiment. Das PHP-Skript lautet wie folgt:

<?php
/**
 * 魔术方法性能探索
 *
 * 构造函数
 *
 * @author TIGERB <http://www.php.cn/;
 */

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 funktioniert Daten der magischen Methode nicht verwenden Wie folgt ist die Einheit Mikrosekunde μ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

PHP5.6 verwendet die Daten der magischen Methode wie folgt, die Einheit ist Mikrosekunde μ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

PHP7.0 verwendet nicht die magische Methode. Die Daten sind wie folgt, in Mikrosekunden

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

PHP7.0 verwendet die Daten der magischen Methode wie folgt, in Mikrosekunden μm

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

Aus den obigen Daten können wir sehen:

Die durchschnittliche Ausführungszeit von Skripten, die den Aufruf verwenden, ist langsamer. Wenn sie nicht verwendet wird, ist sie ungefähr 2 Mikrosekunden langsamer sowohl in PHP5.6 als auch in PHP7.0.

callStatic

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

<?php
/**
 * 魔术方法性能探索
 *
 * 静态重载函数
 *
 * @author TIGERB <http://www.php.cn/;
 */

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 funktioniert Daten der magischen Methode nicht verwenden Wie folgt ist die Einheit Mikrosekunde μ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

PHP5.6 verwendet die Daten der magischen Methode wie folgt, die Einheit ist Mikrosekunde μm

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

PHP7.0 verwendet nicht die magische Methode. Die Daten sind wie folgt, in Mikrosekunden

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

PHP7.0 verwendet die Daten der magischen Methode wie folgt, in Mikrosekunden μ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

Aus den obigen Daten können wir sehen:

wird mit dem callStatic-Skript in PHP5.6 ausgeführt. Die durchschnittliche Zeit ist langsamer als ohne Verwendung, ungefähr 3 Mikrosekunden; die durchschnittliche Ausführungszeit von Skripten, die callStatic in PHP7.0 verwenden, ist ungefähr gleich dazu ohne callStatic;

set

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

<?php
/**
 * 魔术方法性能探索
 *
 * 设置私有属性set
 *
 * @author TIGERB <http://www.php.cn/;
 */

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 verwendet nicht die magische Methode. Die Daten lauten wie folgt, in Mikrosekunden μ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

PHP5.6 verwendet die Daten der magischen Methode als folgt, in Mikrosekunden μ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

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

PHP7.0 verwendet die magische Methode. Die Daten sind wie folgt in Mikrosekunden:

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

Aus den oben genannten Daten können wir ersehen:

Die durchschnittliche Ausführungszeit eines Skripts, das set verwendet, ist langsamer als bei Nichtverwendung, ungefähr 2 Mikrosekunden langsamer, sowohl in PHP5.6 als auch in PHP7. 0.

get

Als nächstes werfen wir einen Blick auf das Get-Experiment. Das PHP-Skript sieht wie folgt aus:

<?php
/**
 * 魔术方法性能探索
 *
 * 读取私有属性get
 *
 * @author TIGERB <http://www.php.cn/;
 */

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

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

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

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

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

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

结语

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

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

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

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

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

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

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

Das obige ist der detaillierte Inhalt vonBeispielcode, der die Leistung von PHP-Magic-Funktionen im Detail erklärt. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!

Stellungnahme：

Der Inhalt dieses Artikels wird freiwillig von Internetnutzern beigesteuert und das Urheberrecht liegt beim ursprünglichen Autor. Diese Website übernimmt keine entsprechende rechtliche Verantwortung. Wenn Sie Inhalte finden, bei denen der Verdacht eines Plagiats oder einer Rechtsverletzung besteht, wenden Sie sich bitte an admin@php.cn

Vorheriger Artikel：Detaillierte Erläuterung des Beispielcodes für PHP zum Abfangen von n Zeichen beginnend an einer bestimmten Position in einem GBK-DokumentNächster Artikel：Detaillierte Erläuterung des Beispielcodes für PHP zum Abfangen von n Zeichen beginnend an einer bestimmten Position in einem GBK-Dokument

In Verbindung stehende Artikel

Mehr sehen