PHP魔法函数性能分析

女爷i 2023-10-05 10:41 43阅读 0赞

## 前言 ##

曾经记得鸟哥Laruence提过不建议使用"魔术方法"，自此之后一旦涉及使用魔术方法的地方，我都会下意识的想一下，这样写真的好吗？由于这一到两年来一直忙于工作和学习新的知识，所以在这道坎儿上一直没有做深入的探索一直恍恍惚惚过去了，今年是我进行深入学习的一年，因此现在必须对这个问题做个了结了。我们先来看看鸟哥Laruence博客曾经提到的：

> 当我把PPT分享给公司的同事的时候, 会有人质疑, 魔术方法都不让用?  
> 优化的建议, 是建议, 是防止大家滥用, 肆无忌惮的用. 如果你能在写代码的时候, 能意识到, 什么慢, 什么快, 从而避免一些没有必要的对魔术方法的调用, 那就是这个优化建议所追求的效果了

## 疑惑 ##

1.  魔术方法真的性能比较差吗？
2.  PHP7里使用魔术方法的性能还是存在问题吗？
3.  我们应该如何合理的使用魔术方法？

## 方案 ##

面对我的疑惑，我的方案是:

*  统计对比使用魔术方法和不使用魔术方法脚本执行的时间差异
 *  PHP5.6.26-1 下连续执行脚本n次
 *  统计执行时间的平均值/最小值/最大值
 *  PHP7.0.12-2 下连续执行脚本n次
 *  统计执行时间的平均值/最小值/最大值

目前个人能力有限，只能通过这种方式，如果你有更好的方案或者建议可以告诉我，谢谢，haha~

## 测试 ##

#### \_\_construct ####

首先我们先来看看构造函数\_\_construct的实验，php脚本如下：

1.  `<?php`
2.  `/**`
3.  `* 魔术方法性能探索`
4.  `*`
5.  `* 构造函数`
6.  `*`
7.  `* @author TIGERB <https://github.com/TIGERB>`
8.  `*/`
9.  
10. `require('./function.php');`
11. `if (!isset($argv[1])) {`
12. `die('error: variable is_use_magic is empty');`
13. `}`
14. `$is_use_magic = $argv[1];`
15. 
16. `/**`
17. `* 构造函数使用类名`
18. `*/`
19. `class ClassOne`
20. `{`
21. `public function classOne()`
22. `{`
23. `# code...`
24. `}`
25. `}`
26. 
27. `/**`
28. `* 构造函数使用魔术函数__construct`
29. `*/`
30. `class ClassTwo`
31. `{`
32. `public function __construct()`
33. `{`
34. `# code...`
35. `}`
36. `}`
37. 
38. `$a = getmicrotime();`
39. `if ($is_use_magic === 'no_magic') {`
40. `new ClassOne();`
41. `}else {`
42. `new ClassTwo();`
43. `}`
44. `$b = getmicrotime();`
45. 
46. `echo ($b-$a) . "\n";`

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

1.  `// PHP5.6中连续调用脚本10000次`
2.  `sh test 10000 no_magic php5 construct`
3.  
4.  `// 运行数据统计脚本`
5.  `sh analysis ./logs/__construct_no_magic_php5.log 10000`
6.  
7.  `// 结果`
8.  `avg: 34μm`
9.  `max: 483μm`
10. `min: 26μm`

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

1.  `// PHP5.6中连续调用脚本10000次`
2.  `sh test 10000 magic php5 construct`
3.  
4.  `// 运行数据统计脚本`
5.  `sh analysis ./logs/__construct_magic_php5.log 10000`
6.  
7.  `// 结果`
8.  `avg: 28μm`
9.  `max: 896μm`
10. `min: 20μm`

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

1.  `// PHP7.0中连续调用脚本10000次`
2.  `sh test 10000 no_magic php construct`
3.  
4.  `// 运行数据统计脚本`
5.  `sh analysis ./logs/__construct_no_magic_php.log 10000`
6.  
7.  `// 结果`
8.  `avg: 19μm`
9.  `max: 819μm`
10. `min: 13μm`

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

1.  `// PHP7.0中连续调用脚本10000次`
2.  `sh test 10000 magic php construct`
3.  
4.  `// 运行数据统计脚本`
5.  `sh analysis ./logs/__construct_magic_php.log 10000`
6.  
7.  `// 结果`
8.  `avg: 14μm`
9.  `max: 157μm`
10. `min: 10μm`

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

> 使用\_\_construct作为构造函数的脚本执行的平均时间是要快于使用类名作为构造函数的，\_\_大概快5到6微秒\_\_，不论是在php5.6还是php7.0中。

#### \_\_call ####

接着，我们来看看\_\_call的实验，php脚本如下：

1.  `<?php`
2.  `/**`
3.  `* 魔术方法性能探索`
4.  `*`
5.  `* 构造函数`
6.  `*`
7.  `* @author TIGERB <https://github.com/TIGERB>`
8.  `*/`
9.  
10. `require('./function.php');`
11. `if (!isset($argv[1])) {`
12. `die('error: variable is_use_magic is empty');`
13. `}`
14. `$is_use_magic = $argv[1];`
15. 
16. `/**`
17. `* 构造函数使用类名`
18. `*/`
19. `class ClassOne`
20. `{`
21. `public function __construct()`
22. `{`
23. `# code...`
24. `}`
25. 
26. `public function test()`
27. `{`
28. `# code...`
29. `}`
30. `}`
31. 
32. `/**`
33. `* 构造函数使用魔术函数__construct`
34. `*/`
35. `class ClassTwo`
36. `{`
37. `public function __construct()`
38. `{`
39. `# code...`
40. `}`
41. 
42. `public function __call($method, $argus)`
43. `{`
44. `# code...`
45. `}`
46. `}`
47. 
48. `$a = getmicrotime();`
49. `if ($is_use_magic === 'no_magic') {`
50. `$instance = new ClassOne();`
51. `$instance->test();`
52. `}else {`
53. `$instance = new ClassTwo();`
54. `$instance->test();`
55. `}`
56. `$b = getmicrotime();`
57. 
58. `echo ($b-$a) . "\n";`

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

1.  `// PHP5.6中连续调用脚本10000次`
2.  `sh test 10000 no_magic php5 call`
3.  
4.  `// 运行数据统计脚本`
5.  `sh analysis ./logs/__call_no_magic_php5.log 10000`
6.  
7.  `// 结果`
8.  `avg: 27μm`
9.  `max: 206μm`
10. `min: 20μm`

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

1.  `// PHP5.6中连续调用脚本10000次`
2.  `sh test 10000 magic php5 call`
3.  
4.  `// 运行数据统计脚本`
5.  `sh analysis ./logs/__call_magic_php5.log 10000`
6.  
7.  `// 结果`
8.  `avg: 29μm`
9.  `max: 392μm`
10. `min: 22μm`

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

1.  `// PHP7.0中连续调用脚本10000次`
2.  `sh test 10000 no_magic php call`
3.  
4.  `// 运行数据统计脚本`
5.  `sh analysis ./logs/__call_no_magic_php.log 10000`
6.  
7.  `// 结果`
8.  `avg: 16μm`
9.  `max: 256μm`
10. `min: 10μm`

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

1.  `// PHP7.0中连续调用脚本10000次`
2.  `sh test 10000 magic php call`
3.  
4.  `// 运行数据统计脚本`
5.  `sh analysis ./logs/__call_magic_php.log 10000`
6.  
7.  `// 结果`
8.  `avg: 18μm`
9.  `max: 2459μm`
10. `min: 11μm`

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

> 使用\_\_call的脚本执行的平均时间是要慢于不使用，\_\_大概慢2微秒\_\_，不论是在php5.6还是php7.0中。

#### \_\_callStatic ####

接着，我们来看看\_\_callStatic的实验，php脚本如下：

1.  `<?php`
2.  `/**`
3.  `* 魔术方法性能探索`
4.  `*`
5.  `* 静态重载函数`
6.  `*`
7.  `* @author TIGERB <https://github.com/TIGERB>`
8.  `*/`
9.  
10. `require('./function.php');`
11. `if (!isset($argv[1])) {`
12. `die('error: variable is_use_magic is empty');`
13. `}`
14. `$is_use_magic = $argv[1];`
15. 
16. `/**`
17. `* 存在test静态方法`
18. `*/`
19. `class ClassOne`
20. `{`
21. `public function __construct()`
22. `{`
23. `# code...`
24. `}`
25. 
26. `public static function test()`
27. `{`
28. `# code...`
29. `}`
30. `}`
31. 
32. `/**`
33. `* 使用重载实现test`
34. `*/`
35. `class ClassTwo`
36. `{`
37. `public function __construct()`
38. `{`
39. `# code...`
40. `}`
41. 
42. `public static function __callStatic($method, $argus)`
43. `{`
44. `# code...`
45. `}`
46. `}`
47. 
48. `$a = getmicrotime();`
49. `if ($is_use_magic === 'no_magic') {`
50. `ClassOne::test();`
51. `}else {`
52. `ClassTwo::test();`
53. `}`
54. `$b = getmicrotime();`
55. 
56. `echo ($b-$a) . "\n";`

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

1.  `// PHP5.6中连续调用脚本10000次`
2.  `sh test 10000 no_magic php5 callStatic`
3.  
4.  `// 运行数据统计脚本`
5.  `sh analysis ./logs/__callStatic_no_magic_php5.log 10000`
6.  
7.  `// 结果`
8.  `avg: 25μm`
9.  `max: 129μm`
10. `min: 19μm`

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

1.  `// PHP5.6中连续调用脚本10000次`
2.  `sh test 10000 magic php5 callStatic`
3.  
4.  `// 运行数据统计脚本`
5.  `sh analysis ./logs/__callStatic_magic_php5.log 10000`
6.  
7.  `// 结果`
8.  `avg: 28μm`
9.  `max: 580μm`
10. `min: 20μm`

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

1.  `// PHP7.0中连续调用脚本10000次`
2.  `sh test 10000 no_magic php callStatic`
3.  
4.  `// 运行数据统计脚本`
5.  `sh analysis ./logs/__callStatic_no_magic_php.log 10000`
6.  
7.  `// 结果`
8.  `avg: 14μm`
9.  `max: 130μm`
10. `min: 9μm`

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

1.  `// PHP7.0中连续调用脚本10000次`
2.  `sh test 10000 magic php callStatic`
3.  
4.  `// 运行数据统计脚本`
5.  `sh analysis ./logs/__callStatic_magic_php.log 10000`
6.  
7.  `// 结果`
8.  `avg: 14μm`
9.  `max: 159μm`
10. `min: 10μm`

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

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

#### \_\_set ####

接着，我们来看看\_\_set的实验，php脚本如下：

1.  `<?php`
2.  `/**`
3.  `* 魔术方法性能探索`
4.  `*`
5.  `* 设置私有属性__set`
6.  `*`
7.  `* @author TIGERB <https://github.com/TIGERB>`
8.  `*/`
9.  
10. `require('./function.php');`
11. `if (!isset($argv[1])) {`
12. `die('error: variable is_use_magic is empty');`
13. `}`
14. `$is_use_magic = $argv[1];`
15. 
16. `/**`
17. `* 实现公共方法设置私有属性`
18. `*/`
19. `class ClassOne`
20. `{`
21. `/**`
22. `* 私有属性`
23. `*`
24. `* @var string`
25. `*/`
26. `private $someVariable = 'private';`
27. 
28. `public function __construct()`
29. `{`
30. `# code...`
31. `}`
32. 
33. `public function setSomeVariable($value = '')`
34. `{`
35. `$this->someVariable = $value;`
36. `}`
37. `}`
38. 
39. `/**`
40. `* 使用_set设置私有属性`
41. `*/`
42. `class ClassTwo`
43. `{`
44. `/**`
45. `* 私有属性`
46. `*`
47. `* @var string`
48. `*/`
49. `private $someVariable = 'private';`
50. 
51. `public function __construct()`
52. `{`
53. `# code...`
54. `}`
55. 
56. `public function __set($name = '', $value = '')`
57. `{`
58. `$this->$name = $value;`
59. `}`
60. `}`
61. 
62. `$a = getmicrotime();`
63. `if ($is_use_magic === 'no_magic') {`
64. `$instance = new ClassOne();`
65. `$instance->setSomeVariable('public');`
66. `}else {`
67. `$instance = new ClassTwo();`
68. `$instance->someVariable = 'public';`
69. `}`
70. `$b = getmicrotime();`
71. 
72. `echo ($b-$a) . "\n";`

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

1.  `// PHP5.6中连续调用脚本10000次`
2.  `sh test 10000 no_magic php5 set`
3.  `// 运行数据统计脚本`
4.  `sh analysis ./logs/__set_no_magic_php5.log 10000`
5.  
6.  `// 结果`
7.  `avg: 31μm`
8.  `max: 110μm`
9.  `min: 24μm`

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

1.  `// PHP5.6中连续调用脚本10000次`
2.  `sh test 10000 magic php5 set`
3.  `// 运行数据统计脚本`
4.  `sh analysis ./logs/__set_magic_php5.log 10000`
5.  
6.  `// 结果`
7.  `avg: 33μm`
8.  `max: 138μm`
9.  `min: 25μm`

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

1.  `// PHP7.0中连续调用脚本10000次`
2.  `sh test 10000 no_magic php set`
3.  `// 运行数据统计脚本`
4.  `sh analysis ./logs/__set_no_magic_php.log 10000`
5.  
6.  `// 结果`
7.  `avg: 15μm`
8.  `max: 441μm`
9.  `min: 11μm`

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

1.  `// PHP7.0中连续调用脚本10000次`
2.  `sh test 10000 magic php set`
3.  `// 运行数据统计脚本`
4.  `sh analysis ./logs/__set_magic_php.log 10000`
5.  
6.  `// 结果`
7.  `avg: 17μm`
8.  `max: 120μm`
9.  `min: 11μm`

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

> 使用\_\_set的脚本执行的平均时间是要慢于不使用，\_\_大概慢2微秒\_\_，不论是在php5.6还是php7.0中。

#### \_\_get ####

接着，我们来看看\_\_get的实验，php脚本如下：

1.  `<?php`
2.  `/**`
3.  `* 魔术方法性能探索`
4.  `*`
5.  `* 读取私有属性__get`
6.  `*`
7.  `* @author TIGERB <https://github.com/TIGERB>`
8.  `*/`
9.  
10. `require('./function.php');`
11. `if (!isset($argv[1])) {`
12. `die('error: variable is_use_magic is empty');`
13. `}`
14. `$is_use_magic = $argv[1];`
15. 
16. `/**`
17. `* 实现公共方法获取私有属性`
18. `*/`
19. `class ClassOne`
20. `{`
21. `/**`
22. `* 私有属性`
23. `*`
24. `* @var string`
25. `*/`
26. `private $someVariable = 'private';`
27. 
28. `public function __construct()`
29. `{`
30. `# code...`
31. `}`
32. 
33. `public function getSomeVariable()`
34. `{`
35. `return $this->someVariable;`
36. `}`
37. `}`
38. 
39. `/**`
40. `* 使用_get获取私有属性`
41. `*/`
42. `class ClassTwo`
43. `{`
44. `/**`
45. `* 私有属性`
46. `*`
47. `* @var string`
48. `*/`
49. `private $someVariable = 'private';`
50. 
51. `public function __construct()`
52. `{`
53. `# code...`
54. `}`
55. 
56. `public function __get($name = '')`
57. `{`
58. `return $this->$name;`
59. `}`
60. `}`
61. 
62. `$a = getmicrotime();`
63. `if ($is_use_magic === 'no_magic') {`
64. `$instance = new ClassOne();`
65. `$instance->getSomeVariable();`
66. `}else {`
67. `$instance = new ClassTwo();`
68. `$instance->someVariable;`
69. `}`
70. `$b = getmicrotime();`
71. 
72. `echo ($b-$a) . "\n";`

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

1.  `// PHP5.6中连续调用脚本10000次`
2.  `sh test 10000 no_magic php5 get`
3.  `// 运行数据统计脚本`
4.  `sh analysis ./logs/__get_no_magic_php5.log 10000`
5.  
6.  `// 结果`
7.  `avg: 28μm`
8.  `max: 590μm`
9.  `min: 20μm`

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

1.  `// PHP5.6中连续调用脚本10000次`
2.  `sh test 10000 magic php5 get`
3.  `// 运行数据统计脚本`
4.  `sh analysis ./logs/__get_magic_php5.log 10000`
5.  
6.  `// 结果`
7.  `avg: 28μm`
8.  `max: 211μm`
9.  `min: 22μm`

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

1.  `// PHP7.0中连续调用脚本10000次`
2.  `sh test 10000 no_magic php get`
3.  `// 运行数据统计脚本`
4.  `sh analysis ./logs/__get_no_magic_php.log 10000`
5.  
6.  `// 结果`
7.  `avg: 16μm`
8.  `max: 295μm`
9.  `min: 10μm`

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

1.  `// PHP7.0中连续调用脚本10000次`
2.  `sh test 10000 magic php get`
3.  `// 运行数据统计脚本`
4.  `sh analysis ./logs/__get_magic_php.log 10000`
5.  
6.  `// 结果`
7.  `avg: 19μm`
8.  `max: 525μm`
9.  `min: 12μm`

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

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

## 结语 ##

这里主要测试了\_\_construct()， \_\_call()， \_\_callStatic()， \_\_get()， \_\_set()这五个常用的且可有其他实现方式代替的魔法函数。通过上面的测试再回来解答我的疑惑

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

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

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

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

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

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

## 脚本源码 ##

> [https://github.com/TIGERB/eas...][https_github.com_TIGERB_eas...]

> 来源： [https://blog.csdn.net/weixin\_34235105/article/details/89088147][https_blog.csdn.net_weixin_34235105_article_details_89088147]

[https_github.com_TIGERB_eas...]: https://github.com/TIGERB/easy-tips/tree/master/php/magic-function
[https_blog.csdn.net_weixin_34235105_article_details_89088147]: https://blog.csdn.net/weixin_34235105/article/details/89088147