0x01 前言

PHP 将所有以 __（两个下划线）开头的类方法保留为魔术方法。
所以在定义类方法时，建议不要以 __ 为前缀。

0x02 PHP魔术方法

魔术方法 基础讲解
__construct() 类的构造函数-实例化一个类之前先执行该方法
__destruct() 类的析构函数-在销毁一个类之前执行该方法
__call() 在对象中调用一个不可访问方法时调用
__callStatic() 在静态上下文中调用一个不可访问方法时调用
__get() 读取不可访问属性的值时调用
__set() 在给不可访问属性赋值时调用
__isset() 当对不可访问属性调用 isset() 或 empty() 时调用
__unset() 当对不可访问属性调用 unset() 时，__unset() 时调用
__sleep() 执行serialize()时，会先调用该魔术方法
__wakeup() 执行unserialize()时，会先调用该魔术方法
__toString() 当一个对象被当作字符串对待的时候，会触发这个魔术方法
__invoke() 当尝试以调用函数的方式调用一个对象时，__invoke() 方法会被自动调用
__set_state() 自 PHP 5.1.0 起当调用 var_export() 导出类时，此静态 方法会被调用
__clone() 当复制完成时，如果定义了 clone() 方法，则新创建的对象（复制生成的对象）中的 clone() 方法会被调用
__debugInfo() 执行var_dump()方法的时候会调用__debugInfo()方法。如果未在对象上定义该方法，则将显示所有公共，受保护和私有属性。 PHP 5.6.0中添加了此功能。
__autoload() 它会在试图使用尚未被定义的类时自动调用。
通过调用此函数，脚本引擎在 PHP 出错失败前有了最后一个机会加载所需的类。

0x03 案例

下面让我们使用实例，来学习魔术方法是如何使用的
PHP版本: 5.6.27-nts
Web服务器软件: Apache

0x03.1 __construct()

0x03.1.1 说明

PHP 5 允行开发者在一个类中定义一个方法作为构造函数。

具有构造函数的类会在每次创建新对象时先调用此方法，所以非常适合在使用对象之前做一些初始化工作。

如果类没有声明该方法，那么类中就会默认存在一个没有参数且内容为空的构造方法。

注意: 如果子类中定义了构造函数则不会隐式调用其父类的构造函数。
要执行父类的构造函数，需要在子类的构造函数中调用 parent::__construct() 。
如果子类没有定义构造函数则会如同一个普通的类方法一样从父类继承（假如没有被定义为 private 的话）。

0x03.1.2 类中的声明格式

  1. public function __constrct(参数列表)
  2. {
  3.     // 抒写实际代码
  4. }

0x03.1.3 实例

  1. # 测试代码
  2. <?php
  3. class Person {                                                                      
  4.     public $name;
  5.     public $sex;
  6.     public $age;
  8.     /**
  9.      * 显示声明一个带参数的构造方法
  10.      */                                                                                       
  11.     public function __construct($name='小明', $sex='男', $age=22)
  12.     {      
  13.         $this->name = $name;
  14.         $this->sex = $sex;
  15.         $this->age = $age;
  16.     }
  18.     /**
  19.      * 申明一个普通的类方法
  20.      */
  21.     public function say()
  22.     {
  23.         echo "我叫: " . $this->name . "，性别：" . $this->sex . "，年龄：" . $this->age;
  24.     }                                               
  25. }
  26. ?>
  1. // 创建对象$person_1 且不带任参数
  3. $person_1 = new Person();
  4. $person_1->say();
  6. // 输出结果
  7. // 我叫: 小明，性别：男，年龄：22
  9. //
  1. // 创建对象$person_2 且带参数 $name='张三'
  3. $person_2 = new Person('张三');
  4. $person_2->say();
  6. // 输出结果
  7. // 我叫: 张三，性别：男，年龄：22
  1. // 创建对象$person_3 且带参数 $name='小红'  $sex = '女'  $age = 18
  2. $person_3 = new Person('小红', '女', '18');
  3. $person_3->say();
  5. // 输出结果
  6. // 我叫: 小红，性别：女，年龄：18

在类刚实例化的时候先调用了 __construct 方法进行初始化操作，然后在去调用 say() 方法 ，输出内容

0x03.2 __destruct()

0x03.2.1 说明

PHP 5 引入了析构函数的概念
析构函数方法允许在销毁一个类之前执行的一些操作或完成一些功能

例如说：现在插件了一个文件类，我们在使用完文件以后就可以通过该方法简单合理的关闭文件

0x03.2.2 类中的声明格式

  1. public function __destruct()
  2. {
  3.     // 抒写实际代码
  4. }

注意：析构函数不能带有任何参数

0x03.2.3 实例

  1. # 测试代码
  3. <?php
  4. class Person {                                                                      
  5.     public $name;
  6.     public $sex;
  7.     public $age;
  9.     /**
  10.      * 显示声明一个带参数的构造方法
  11.      */                                                                                       
  12.     public function __construct($name='小明', $sex='男', $age=22)
  13.     {      
  14.         $this->name = $name;
  15.     }
  17.     /**
  18.      * 申明一个普通的类方法
  19.      */
  20.     public function say()
  21.     {
  22.         echo "我叫: " . $this->name . "，性别：" . $this->sex . "，年龄：" . $this->age;
  23.     }
  25.     /**
  26.      * 声明一个析构方法
  27.      */
  28.     public function __destruct()
  29.     {
  30.         echo '我叫：' . $this->name . '我被删除了';
  31.     }
  32. }
  33. ?>
  1. // 创建对象 $person_1 并且使用 unset() 函数销毁创建的对象
  2. $person_1 =new Person('张三');
  3. $person_1->say();
  4. unset($person_1);
  6. // 输出结果
  7. // 先输出：我叫: 张三，性别：男，年龄：22
  8. // 然后在输出：我叫：张三我被删除了
  10. // 执行顺序
  11. // 先执行 __construct() 方法进行赋值
  12. // 然后调用 say() 类方法  输出：我叫: 张三，性别：男，年龄：22
  13. // 接着使用 unset() 函数 销毁创建的对象 触发了方法 __destruct() 然后输出：我叫：张三我被删除了

0x03.3 __call()

0x03.3.1 说明

在对象中调用一个不可访问方法时，该方法会被调用

该方法有固定的两个参数

  • $name 参数是要调用的方法名称。
  • $arguments 参数是一个枚举数组，包含着要传递给方法 $name 的参数。

为了避免当调用的方法不存在时产生错误，而意外的导致程序中止，可以使用 __call() 方法来避免。
该方法在调用一个不存在的方法时会自动调用，使程序会仍然继续执行下去。

0x03.3.2 类中的声明格式

  1. public function __call(string $name, array $arguments)
  2. {
  3.     // 抒写实际代码
  4. }

0x03.3.3 实例

  1. # 测试代码
  3. <?php
  4. class MethodTest 
  5. {
  7.     /**
  8.      * 申明一个普通的类方法
  9.      */
  10.     public function hello()
  11.     {
  12.         echo '你好呀，我是一个存在的方法: hello';
  13.     }
  15.     /**
  16.      * 声明此方法用来处理调用对象中不存在的方法
  17.      */
  18.     public function __call($name, $arguments) 
  19.     {
  20.         echo '你所调用的函数方法: ' . $name . '不存在' . '<br/>';
  21.         echo '传递的参数为: ';
  22.         print_r($arguments);
  23.     }
  24. }
  25. ?>
  1. // 实例化一个对象,然后调用一个根本不存在的方法
  2. $obj = new MethodTest;
  3. $obj->runTest('传递参数1', '传递参数2', '传递参数3');
  5. // 输出结果
  6. // 你所调用的函数方法: runTest不存在
  7. // 传递的参数为: Array ( [0] => 传递参数1 [1] => 传递参数2 [2] => 传递参数3 )
  1. // 实例化一个对象,然后调用一个根本不存在的方法,接着在调用一个存在的方法
  2. $obj = new MethodTest;
  3. $obj->runTest('传递参数1', '传递参数2', '传递参数3');
  4. $obj->hello();
  6. // 输出结果
  7. // 你所调用的函数方法: runTest不存在
  8. // 传递的参数为: Array ( [0] => 传递参数1 [1] => 传递参数2 [2] => 传递参数3 ) 
  10. // 你好呀，我是一个存在的方法: hello

0x03.4 __callStatic()

0x03.4.1 说明

在对象中调用一个不可访问的静态方法时，该方法会被调用

该方法有固定的两个参数

  • $name 参数是要调用的方法名称。
  • $arguments 参数是一个枚举数组，包含着要传递给方法 $name 的参数。

为了避免当调用的静态方法不存在时产生错误，而意外的导致程序中止，可以使用 __callStatic() 方法来避免。
该方法在调用一个不存在的静态方法时会自动调用，使程序会仍然继续执行下去。

0x03.4.2 类中的声明格式

  1. public function __callStatic(string $name, array $arguments)
  2. {
  3.     // 抒写实际代码
  4. }

0x03.4.3 实例

  1. # 测试代码
  2. <?php
  3. class StaticMethodTest 
  4. {
  5.     /**
  6.      * 申明一个普通的类方法
  7.      */
  8.     public static function hello()
  9.     {
  10.         echo '你好呀，我是一个存在的静态方法: hello';
  11.     }
  13.     /**
  14.      * 声明此方法用来处理调用对象中不存在的方法
  15.      */
  16.     public static function __callStatic($name, $arguments) 
  17.     {
  18.         echo '你所调用的静态函数方法: ' . $name . '不存在' . '<br/>';
  19.         echo '传递的参数为: ';
  20.         print_r($arguments);
  21.     }
  22. }
  23. ?>
  1. // 实例化一个对象,然后调用一个根本不存在的静态方法
  3. $obj = new StaticMethodTest;
  4. $obj::runTest('传递参数1', '传递参数2', '传递参数3');
  6. // 输出结果
  7. 你所调用的静态函数方法: runTest不存在
  8. 传递的参数为: Array ( [0] => 传递参数1 [1] => 传递参数2 [2] => 传递参数3 )
  1. // 实例化一个对象,然后调用一个根本不存在的静态方法,接着在调用一个存在的静态方法
  2. $obj = new StaticMethodTest;
  3. $obj::runTest('传递参数1', '传递参数2', '传递参数3');
  4. $obj::hello();
  6. // 输出结果
  7. 你所调用的静态函数方法: runTest不存在
  8. 传递的参数为: Array ( [0] => 传递参数1 [1] => 传递参数2 [2] => 传递参数3 ) 
  10. 你好呀，我是一个存在的静态方法: hello

0x03.5 __get()

0x03.5.1 说明

读取不可访问属性的值/不存在的参数时，该方法会被调用

php 面向对象编程中，类的成员属性被设定为 private 后，如果我们在外面调用它则会出现“Fatal error: Cannot access private property”的错误

想要类属性设置 private 依然可以访问，我们可以使用魔术方法__get()来做到

该方法有固定的一个参数

  • $name 该参数是要调用的参数名称

0x03.5.2 类中的声明格式

  1. public function __get($name)
  2. {
  3.     // 抒写实际代码
  4. }

0x03.5.3 实例

  1. <?php
  2. // 测试代码
  3. class Computer
  4. {
  5.     private $brand;
  6.     private $vga_card;
  8.     function __construct($brand = '神州', $vga_card = 'N卡GTX 1060')
  9.     {
  10.         $this->brand = $brand;
  11.         $this->vga_card = $vga_card;
  12.     }
  14.     /**
  15.      * 声明此方法用来处理 读取不可访问属性的值时，该方法会被调用
  16.      * @param $name
  17.      *
  18.      * @return string
  19.      */
  20.     public function __get($name)
  21.     {
  22.         if (!isset($this->$name)) {
  23.             return '属性: ' . $name . '不存在'; 
  24.         }
  25.         return $this->$name;
  26.     }
  27. }
  28. ?>
  1. // 实例化一个对象，然后调用两个私有属性
  3. $computer = new Computer();
  4. echo $computer->brand . "<br>";
  5. echo $computer->vga_card . "<br>";
  7. // 输出结果
  8. // 神州
  9. // N卡GTX 1060
  1. // 实例化一个对象，然后调用一个根本不存在的属性
  3. $computer = new Computer();
  4. echo $computer->xxxx;
  6. // 输出结果
  7. // 属性: xxxx不存在
  9. // 注意，这里会输出 “属性: xxxx不存在” 是因为我在 __get() 方法里面做了判断 
  10. // 就是这个判断 if (!isset($this->$name))

0x03.6 __set()

0x03.6.1 说明

在给不可访问属性赋值时，__set() 会被调用

php 面向对象编程中，类的成员属性被设定为 private 后，如果我们在外面尝试修改它的值则会出现“Cannot access private property”的错误

想要类属性设置 private 依然可以修改，我们可以使用魔术方法 __set()来做到

该方法有固定的二个参数

  • $name 该参数是要设置的参数名称
  • $val 该参数是要设置的内容

0x03.6.2 类中的声明格式

  1. public function __set($name,$val){
  2.     // 抒写实际代码
  3. }

0x03.6.3 实例

  1. <?php
  2. // 测试代码
  3. class main
  4. {
  5.     private $name = '张三';
  7.     /**
  8.      * 声明此方法用来处理 在给不可访问属性赋值时，该方法会被调用
  9.      * 
  10.      * @param $name
  11.      * @param $val
  12.      *
  13.      * @return string
  14.      */
  15.     public function __set($name,$val){
  16.         $this->$name = $val;
  17.     }
  19.     /**
  20.      * 声明此方法用来处理 读取不可访问属性的值时，该方法会被调用
  21.      * @param $name
  22.      *
  23.      * @return string
  24.      */
  25.     public function __get($name)
  26.     {
  27.         if (!isset($this->$name)) {
  28.             return '属性: ' . $name . '不存在'; 
  29.         }
  30.         return $this->$name;
  31.     }
  32. }
  33. ?>
  1. $main = new main();
  2. $main->name = "王五"; // 调用了 __set()魔术方法 修改了私有属性  private $name 的值
  3. echo $main->name; // 调用 __get()魔术方法 读取 private $name 的值
  5. // 输出结果
  6. // 王五

0x03.7 __isset()

0x03.7.1 说明

当对不可访问属性调用 isset() 或 empty() 时 ，__isset() 方法会被调用

0x03.7.2 类中的声明格式

  1. public function __isset($name)
  2. {
  3.     // 抒写实际代码
  4. }

0x03.7.3 实例

  1. <?php
  2. class main
  3. {
  4.     private $name = '张三';
  6.     public function __isset($name)
  7.     {
  8.         if (isset($this->$name)) {
  9.             echo $name . ' 该私有变量存在<br/>';
  10.             return true;
  11.         } else {
  12.             echo $name . ' 该私有变量不存在<br/>';
  13.             return false;
  14.         }
  15.     }
  16. }
  17. ?>
  1. // 使用 isset 判断一下 类私有变量 name 是否存在
  2. $main = new main();
  3. var_dump(isset($main->name));
  5. // 输出结果
  6. // name 该私有变量存在
  7. // bool(true)
  1. // 使用 isset 判断一下 类私有变量 aaa 是否存在
  2. $main = new main();
  3. var_dump(isset($main->aaa));
  5. // 输出结果
  6. // aaa 该私有变量不存在
  7. // bool(false)

0x03.8 __unset()

0x03.8.1 说明

当对不可访问属性调用 unset() 时，__unset() 会被调用

0x03.8.2 类中的声明格式

  1. public function __unset($name) 
  2. {
  3.     // 抒写实际代码
  4. }

0x03.8.3 实例

  1. <?php
  2. class main
  3. {
  4.     private $name = '张三';
  6.     public function __get($name)
  7.     {
  8.         if (!isset($this->$name)) {
  9.             return '属性: ' . $name . "不存在<br/>"; 
  10.         }
  11.         return $this->$name;
  12.     }
  14.     public function __unset($name) 
  15.     {
  16.         echo "该参数 $name 被删除了<br/>";
  17.         unset($this->$name);
  18.     }
  19. }
  20. ?>
  1. $main = new main();
  2. echo $main->name;
  4. // 输出结果
  5. // 张三
  1. $main = new main();
  2. unset($main->name);
  3. echo $main->name;
  5. // 输出结果
  6. // 该参数 name 被删除了
  7. // 属性: name不存在

0x03.9 __sleep()

0x03.9.1 说明

执行serialize()时，先会调用这个函数

serialize() 函数会检查类中是否存在一个魔术方法 __sleep()。

如果存在，该方法会先被调用，然后才执行序列化操作。

此功能可以用于清理对象，并返回一个包含对象中所有应被序列化的变量名称的数组。

如果该方法未返回任何内容，则 NULL 被序列化，并产生一个 E_NOTICE 级别的错误。

0x03.9.2 类中的声明格式

  1. public function __sleep()
  2. {
  3.     // 抒写实际代码
  4. }

0x03.9.3 实例

  1. <?php
  2. class Person
  3. {
  4.     public $name;
  5.     public $sex;
  6.     public $age;
  8.     public function __construct($name='小明', $sex='未知', $age=25)
  9.     {
  10.         $this->name = $name;
  11.         $this->sex  = $sex;
  12.         $this->age  = $age;
  13.     }
  15.     /**
  16.      * @return array
  17.      */
  18.     public function __sleep() {
  19.         echo '当我被外部使用 serialize() 调用时,我会执行 __sleep()方法<br>';
  21.         # 把名字 base64编码 一下确定它进来了该方法
  22.         $this->name = base64_encode($this->name);
  24.         // 这里必须返回一个数值，里边的元素表示返回的属性名称
  25.         // array('name') 表示的就是 $this->name
  26.         // array('sex') 表示的就是 $this->sex
  27.         // 例如:
  28.         // 我这里传了 name 与 sex 那么 serialize() 完毕以后,返回的值就只会带上参数
  29.         // $this->name
  30.         // $this->sex
  31.           //
  32.         // 如果序列化的时候 
  33.           // $this->name 是 小军
  34.         // $this->sex  是 男
  35.                // 
  36.           // 那么下次反序列化的时候 
  37.           // $this->name 值是 小军
  38.         // $this->sex  值是 男
  39.           // $this->age  值是 NULL  因为没有return的时候我没有加上 $this->age
  40.         return array('name', 'sex');
  41.     }
  42. }
  43. ?>
  1. $person = new Person('小军', '男'); // 初始赋值
  2. echo serialize($person);
  4. // 它会执行 __sleep 方法
  5. // 并且 echo 一句话
  6. // 并且 类里面的 $this->name base64编码赋值保存起来
  8. // 执行结果
  9. // 当我被外部使用 serialize() 调用时,我会先执行 __sleep()方法
  10. // O:6:"Person":2:{s:4:"name";s:8:"5bCP5Yab";s:3:"sex";s:3:"男";}

0x03.10 __wakeup()

0x03.10.1 说明

执行unserialize()时，先会调用这个函数

unserialize() 会先检查是否存在一个 __wakeup() 方法。

如果存在，则会先调用 __wakeup 方法，预先准备对象需要的资源

0x03.10.2 类中的声明格式

  1. public function __wakeup()
  2. {
  3.     // 抒写实际代码
  4. }

0x03.10.3 实例

  1. <?php
  2. class Person
  3. {
  4.     public $name;
  5.     public $sex;
  6.     public $age;
  8.     public function __construct($name='小明', $sex='未知', $age=25)
  9.     {
  10.         $this->name = $name;
  11.         $this->sex  = $sex;
  12.         $this->age  = $age;
  13.     }
  15.     /**
  16.      * @return array
  17.      */
  18.     public function __sleep() {
  19.         # 把名字 base64编码 一下确定它进来了该方法
  20.         $this->name = base64_encode($this->name);
  21.         return array('name', 'sex');
  22.     }
  24.     public function __wakeup()
  25.     {
  26.         $this->name = '郑' . base64_decode($this->name);
  27.     }
  28. }
  29. ?>
  1. $person = new Person('小军', '男'); // 初始赋值
  2. $p = serialize($person);
  4. $p1 = unserialize($p);
  6. var_dump($p1->name);
  7. var_dump($p1->sex);
  8. var_dump($p1->age);
  10. // 执行结果
  11. // 执行结果中名字返回 "郑小军" 是因为，执行了 __wakeup() 方法
  12. // 在 __wakeup() 方法里面,我把名字base64解码并在前面添加了一个 “郑” 字
  13. // string(9) "郑小军"
  14. // string(3) "男"
  15. // NULL

0x03.11 __toString()

0x03.11.1 说明

该方法用于一个类被当成字符串时应怎样回应。

例如 echo $obj; 应该显示些什么。

此方法必须返回一个字符串，否则将发出一条 E_RECOVERABLE_ERROR 级别的致命错误。

0x03.11.2 类中的声明格式

  1. public function __toString() {
  2. // 抒写实际代码
  3. }

0x03.11.3 实例

  1. <?php
  2. class TestClass
  3. {
  4.     public $foo;
  6.     public function __construct($foo) 
  7.     {
  8.         $this->foo = $foo;
  9.     }
  11.     public function __toString() {
  12.         return '世界 ' . $this->foo;
  13.     }
  14. }
  15. ?>
  1. $class = new TestClass('你好');
  2. echo $class;
  4. // 执行结果
  5. // 使用 echo 触发了 __toString() 方法
  6. // 记得返回必须是字符串！！！
  7. // echo 的时候多了“世界”两个字是因为我在 _toString() 方法，return的
  9. // 世界 你好

0x03.12 __invoke()

0x03.12.1 说明

当尝试以调用函数的方式调用一个对象时，__invoke() 方法会被自动调用

0x03.12.2 类中的声明格式

  1. public function __invoke(参数列表)
  2. {
  3.     // 抒写实际代码
  4. }

0x03.12.3 实例

  1. <?php
  2. class CallableClass 
  3. {
  4.     private $name = '测试';
  6.     function __invoke($x) {
  7.         if (!isset($this->$x)) {
  8.             return $x . '这个属性在类中不存在';
  9.         }
  10.         return $this->$x;
  11.     }
  12. }
  1. // 把类当函数调用的时候 类的__invoke() 方法会执行
  2. $obj = new CallableClass;
  3. echo $obj('name');
  5. // 输出结果
  6. // 测试
  1. $obj = new CallableClass;
  2. echo $obj('xxx');
  4. // 执行结果
  5. // xxx这个属性在类中不存在

0x03.13 __set_state()

0x03.13.1 说明

自 PHP 5.1.0 起当调用 var_export() 导出类时，此静态方法会被调用。

本方法的唯一参数是一个数组，其中包含按 array(‘property’ => value, …) 格式排列的类属性。

0x03.13.2 类中的声明格式

  1. public static function __set_state($array)
  2. {
  3.     // 抒写实际代码
  4. }

0x03.13.3 实例

  1. <?php
  2. class A
  3. {
  4.     public $var1;
  5.     public $var2;
  7.     public static function __set_state($array)
  8.     {
  9.         $obj = new A;
  10.         $obj->var1 = $array['var1'];
  11.         $obj->var2 = $array['var2'];
  12.         return $obj;
  13.     }
  14. }
  1. $a = new A;
  2. $a->var1 = 5;
  3. $a->var2 = 'foo';
  5. echo var_export($a, true);
  7. // 执行结果
  8. // A::__set_state(array(
  9. //    'var1' => 5,
  10. //    'var2' => 'foo',
  11. // ))

0x03.14 __clone()

0x03.14.1 说明

当对象复制完成时调用，利用clone 关键字来触发

0x03.14.2 类中的声明格式

  1. function __clone() {
  2. // 抒写实际代码
  3. }

0x03.14.3 实例

  1. <?php
  2. class SubObject
  3. {
  4.     static $instances = 0;
  5.     public $instance;
  7.     public function __construct() {
  8.         $this->instance = ++self::$instances;
  9.     }
  11.     public function __clone() {
  12.         $this->instance = ++self::$instances;
  13.     }
  14. }
  16. class MyCloneable
  17. {
  18.     public $object1;
  19.     public $object2;
  21.     function __clone()
  22.     {
  24.         // 强制复制一份this->object， 否则仍然指向同一个对象
  25.         $this->object1 = clone $this->object1;
  26.     }
  27. }
  1. $obj = new MyCloneable();
  3. $obj->object1 = new SubObject();
  4. $obj->object2 = new SubObject();
  6. $obj2 = clone $obj;
  9. print("原始对象:\n");
  10. print_r($obj);
  12. print("克隆的对象:\n");
  13. print_r($obj2);
  15. // 执行结果
  17. // 原始对象:
  18. // MyCloneable Object
  19. // (
  20. //     [object1] => SubObject Object
  21. //         (
  22. //             [instance] => 1
  23. //         )
  24. // 
  25. //     [object2] => SubObject Object
  26. //         (
  27. //             [instance] => 2
  28. //         )
  29. // )
  31. // 克隆的对象:
  32. // MyCloneable Object
  33. // (
  34. //     [object1] => SubObject Object
  35. //         (
  36. //             [instance] => 3
  37. //         )
  38. // 
  39. //     [object2] => SubObject Object
  40. //         (
  41. //             [instance] => 2
  42. //         )
  43. // )

0x03.15 __debugInfo()

0x03.15.1 说明

该方法在var_dump()类对象的时候被调用，如果没有定义该方法，则var_dump会打印出所有的类属性

注意：它的返回必须是数组！！！

注意：__debugInfo()方法只能用于PHP 5.6.0及更高版本。

0x03.15.2 类中的声明格式

  1. public function __debugInfo() {
  2.   // 抒写实际代码
  3. }

0x03.15.3 实例

  1. <?php
  2. class C {
  3.     private $test_value;
  5.     public function __construct($val) {
  6.         $this->test_value = $val;
  8.     }
  10.     /**
  11.      * @return array
  12.      */
  13.     public function __debugInfo() {
  14.         return [$this->test_value];
  15.     }
  16. }
  1. var_dump(new C('测试内容'));
  3. // 输出结果
  4. // object(C)#1 (1) {
  5. //   [0]=>
  6. //   string(12) "测试内容"
  7. // }

0x03.16 __autoload()

0x03.16.1 说明

__autoload() 方法用于自动加载类

在实际项目中，不可能把所有的类都写在一个 PHP 文件中，当在一个 PHP 文件中需要调用另一个文件中声明的类时，就需要通过 include 把这个文件引入。

不过有的时候，在文件众多的项目中，要一一将所需类的文件都 include 进来，一个很大的烦恼是不得不在每个类文件开头写一个长长的包含文件的列表。我们能不能在用到什么类的时候，再把这个类所在的 php 文件导入呢？

为此，PHP 提供了 __autoload() 方法，它会在试图使用尚未被定义的类时自动调用。通过调用此函数，脚本引擎在 PHP 出错失败前有了最后一个机会加载所需的类。

__autoload() 方法接收的一个参数，就是欲加载的类的类名，所以这时候需要类名与文件名对应，如 Person.php ，对应的类名就是 Pserson 。

0x03.16.2实例

  1. // 文件名称：Person.php
  3. <?php
  4. class Person {
  5.     private $name;
  6.     private $age;
  8.     function __construct($name, $age) {
  9.             $this->name = $name;
  10.       $this->age = $age;
  11.     }
  13.     function say() {
  14.       echo "我的名字叫：".$this->name."<br />";
  15.       echo "我的年龄是：".$this->age;
  16.     }
  17. }
  18. ?>
  1. // 文件名称：test.php
  2. <?php
  3. function __autoload($class_name) 
  4. {
  5.     require_once $class_name.'.php';
  6. }
  8. //当前页面 Person 类不存在则自动调用 __autoload() 方法，传入参数 Person
  9. $p1 = new Person("小明","25");
  10. $p1->say();
  11. ?>
  13. 运行 test.php 输出：
  14. 我的名字叫：小明
  15. 我的年龄是：25