PHP魔法函数性能分析

224 篇文章 1 订阅
17 篇文章 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://blog.csdn.net/weixin_34235105/article/details/89088147
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值