PHP之十六個魔術方法詳細介紹

時間  2019-12-09
標籤 php 之十 六個 方法 詳細 介紹 欄目 PHP 简体版
原文   原文鏈接

PHP中把以兩個下劃線__開頭的方法稱爲魔術方法(Magic methods)php

魔術方法包括：數據庫

    • __construct()，類的構造函數
    • __destruct()，類的析構函數
    • __call()，在對象中調用一個不可訪問方法時調用
    • __callStatic()，用靜態方式中調用一個不可訪問方法時調用
    • __get()，得到一個類的成員變量時調用
    • __set()，設置一個類的成員變量時調用
    • __isset()，當對不可訪問屬性調用isset()或empty()時調用
    • __unset()，當對不可訪問屬性調用unset()時被調用。
    • __sleep()，執行serialize()時，先會調用這個函數
    • __wakeup()，執行unserialize()時，先會調用這個函數
    • __toString()，類被當成字符串時的迴應方法
    • __invoke()，調用函數的方式調用一個對象時的迴應方法
    • __set_state()，調用var_export()導出類時，此靜態方法會被調用。
    • __clone()，當對象複製完成時調用
    • __autoload()，嘗試加載未定義的類
    • __debugInfo()，打印所需調試信息

      1、 __construct()，類的構造函數
      編程

      php中構造方法是對象建立完成後第一個被對象自動調用的方法。在每一個類中都有一個構造方法，若是沒有顯示地聲明它，那麼類中都會默認存在一個沒有參數且內容爲空的構造方法。數組

      一、 構造方法的做用函數

      一般構造方法被用來執行一些有用的初始化任務，如對成員屬性在建立對象時賦予初始值。測試

      二、 構造方法的在類中的聲明格式
      ui

      ?
      1
      2
      3
      4
      function __constrct([參數列表]){
       
         方法體 //一般用來對成員屬性進行初始化賦值
      }

      三、 在類中聲明構造方法須要注意的事項this

      一、在同一個類中只能聲明一個構造方法，緣由是，PHP不支持構造函數重載。spa

      二、構造方法名稱是以兩個下畫線開始的__construct()
      .net

      下面是它的例子：

      ?
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      <?php
         class Person
         {                                  
             public $name ;   
             public $age ;   
             public $sex ;   
                                        
           /**
            * 顯示聲明一個構造方法且帶參數
            */                                           
           public function __construct( $name = "" , $sex = "男" , $age =22)
           {  
             $this ->name = $name ;
             $this ->sex = $sex ;
             $this ->age = $age ;
           }
           
           /**
            * say 方法
            */
           public function say()
           {
             echo "我叫：" . $this ->name . "，性別：" . $this ->sex . "，年齡：" . $this ->age;
           } 
                                                     
         }

      建立對象$Person1且不帶任參數

      ?
      1
      2
      $Person1 = new Person();
      echo $Person1 ->say(); //輸出:我叫：，性別：男，年齡：27

      建立對象$Person2且帶參數「小明」

      ?
      1
      2
      $Person2 = new Person( "小明" );
      echo $Person2 ->say(); //輸出：我叫：張三，性別：男，年齡：27

      建立對象$Person3且帶三個參數

      ?
      1
      2
      $Person3 = new Person( "李四" , "男" ,25);
      echo $Person3 ->say(); //輸出：我叫：李四，性別：男，年齡：25

      2、__destruct()，類的析構函數

      經過上面的講解，如今咱們已經知道了什麼叫構造方法。那麼與構造方法對應的就是析構方法。

      析構方法容許在銷燬一個類以前執行的一些操做或完成一些功能，好比說關閉文件、釋放結果集等。

      析構方法是PHP5才引進的新內容。

      析造方法的聲明格式與構造方法 __construct() 比較相似，也是以兩個下劃線開始的方法 __destruct() ，這種析構方法名稱也是固定的。

      一、 析構方法的聲明格式

      ?
      1
      2
      3
      4
      function __destruct()
      {
        //方法體
      }

      注意：析構函數不能帶有任何參數。

      二、 析構方法的做用

      通常來講，析構方法在PHP中並非很經常使用，它屬類中可選擇的一部分，一般用來完成一些在對象銷燬前的清理任務。
      舉例演示，以下：

      ?
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      28
      29
      30
      31
      32
      33
      <?php
      class Person{  
                                   
         public $name ;    
         public $age ;    
         public $sex ;    
                                         
         public function __construct( $name = "" , $sex = "男" , $age =22)
         { 
           $this ->name = $name ;
           $this ->sex = $sex ;
           $this ->age = $age ;
         }
         
         /**
          * say 說話方法
          */
         public function say()
         {
           echo "我叫：" . $this ->name. "，性別：" . $this ->sex. "，年齡：" . $this ->age;
         } 
         
         /**
          * 聲明一個析構方法
          */
         public function __destruct()
         {
             echo "我以爲我還能夠再搶救一下，個人名字叫" . $this ->name;
         }
      }
       
      $Person = new Person( "小明" );
      unset( $Person ); //銷燬上面建立的對象$Person

      上面的程序運行時輸出：

      我以爲我還能夠再搶救一下，個人名字叫小明

      3、 __call()，在對象中調用一個不可訪問方法時調用。

      該方法有兩個參數，第一個參數 $function_name 會自動接收不存在的方法名，第二個 $arguments 則以數組的方式接收不存在方法的多個參數。

      一、 __call() 方法的格式：

      ?
      1
      2
      3
      4
      function __call(string $function_name , array $arguments )
      {
         // 方法體
      }

      二、 __call() 方法的做用：

      爲了不當調用的方法不存在時產生錯誤，而意外的致使程序停止，可使用 __call() 方法來避免。

      該方法在調用的方法不存在時會自動調用，程序仍會繼續執行下去。

      請參考以下代碼：

      ?
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      <?php
      class Person
      {              
         function say()
         {
                      
             echo "Hello, world!<br>" ;
         }  
           
         /**
          * 聲明此方法用來處理調用對象中不存在的方法
          */
         function __call( $funName , $arguments )
         {
            echo "你所調用的函數：" . $funName . "(參數：" ; // 輸出調用不存在的方法名
            print_r( $arguments ); // 輸出調用不存在的方法時的參數列表
            echo ")不存在！<br>\n" ; // 結束換行          
         }                    
      }
      $Person = new Person();     
      $Person ->run( "teacher" ); // 調用對象中不存在的方法，則自動調用了對象中的__call()方法
      $Person ->eat( "小明" , "蘋果" );      
      $Person ->say();

      運行結果：

      你所調用的函數：run(參數：Array ( [0] => teacher ) )不存在！

      你所調用的函數：eat(參數：Array ( [0] => 小明 [1] => 蘋果 ) )不存在！

      Hello, world!

      4、 __callStatic()，用靜態方式中調用一個不可訪問方法時調用

      此方法與上面所說的 __call() 功能除了 __callStatic() 是未靜態方法準備的以外，其它都是同樣的。

      請看下面代碼：

      ?
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      <?php
      class Person
      {
         function say()
         {
       
           echo "Hello, world!<br>" ;
         }
       
         /**
          * 聲明此方法用來處理調用對象中不存在的方法
          */
         public static function __callStatic( $funName , $arguments )
         {
           echo "你所調用的靜態方法：" . $funName . "(參數：" ; // 輸出調用不存在的方法名
           print_r( $arguments ); // 輸出調用不存在的方法時的參數列表
           echo ")不存在！<br>\n" ; // 結束換行
         }
      }
      $Person = new Person();
      $Person ::run( "teacher" ); // 調用對象中不存在的方法，則自動調用了對象中的__call()方法
      $Person ::eat( "小明" , "蘋果" );
      $Person ->say();

      運行結果以下：

      你所調用的靜態方法：run(參數：Array ( [0] => teacher ) )不存在！
      你所調用的靜態方法：eat(參數：Array ( [0] => 小明 [1] => 蘋果 ) )不存在！
      Hello, world!

      5、 __get()，得到一個類的成員變量時調用

      在 php 面向對象編程中，類的成員屬性被設定爲 private 後，若是咱們試圖在外面調用它則會出現「不能訪問某個私有屬性」的錯誤。那麼爲了解決這個問題，咱們可使用魔術方法 __get()。

      魔術方法__get()的做用

      在程序運行過程當中，經過它能夠在對象的外部獲取私有成員屬性的值。

      咱們經過下面的 __get() 的實例來更進一步的鏈接它吧：

      ?
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      28
      29
      30
      31
      32
      33
      34
      <?php
      class Person
      {
         private $name ;
         private $age ;
       
         function __construct( $name = "" , $age =1)
         {
           $this ->name = $name ;
           $this ->age = $age ;
         }
       
         /**
          * 在類中添加__get()方法，在直接獲取屬性值時自動調用一次，以屬性名做爲參數傳入並處理
          * @param $propertyName
          *
          * @return int
          */
         public function __get( $propertyName )
         { 
           if ( $propertyName == "age" ) {
             if ( $this ->age > 30) {
               return $this ->age - 10;
             } else {
               return $this -> $propertyName ;
             }
           } else {
             return $this -> $propertyName ;
           }
         }
      }
      $Person = new Person( "小明" , 60);  // 經過Person類實例化的對象，並經過構造方法爲屬性賦初值
      echo "姓名：" . $Person ->name . "<br>" ;  // 直接訪問私有屬性name，自動調用了__get()方法能夠間接獲取
      echo "年齡：" . $Person ->age . "<br>" ;  // 自動調用了__get()方法，根據對象自己的狀況會返回不一樣的值

      運行結果：

      姓名：小明
      年齡：50

      6、 __set()，設置一個類的成員變量時調用

      __set() 的做用：

      __set( $property, $value )` 方法用來設置私有屬性， 給一個未定義的屬性賦值時，此方法會被觸發，傳遞的參數是被設置的屬性名和值。

      請看下面的演示代碼：

      ?
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      28
      29
      30
      31
      32
      33
      34
      35
      36
      37
      38
      39
      40
      41
      42
      <?php
      class Person
      {
         private $name ;
         private $age ;
       
         public function __construct( $name = "" , $age =25)
         {
           $this ->name = $name ;
           $this ->age = $age ;
         }
       
         /**
          * 聲明魔術方法須要兩個參數，真接爲私有屬性賦值時自動調用，並能夠屏蔽一些非法賦值
          * @param $property
          * @param $value
          */
         public function __set( $property , $value ) {
           if ( $property == "age" )
           {
             if ( $value > 150 || $value < 0) {
               return ;
             }
           }
           $this -> $property = $value ;
         }
       
         /**
          * 在類中聲明說話的方法，將全部的私有屬性說出
          */
         public function say(){
           echo "我叫" . $this ->name. "，今年" . $this ->age. "歲了" ;
         }
      }
       
      $Person = new Person( "小明" , 25); //注意，初始值將被下面所改變
      //自動調用了__set()函數，將屬性名name傳給第一個參數，將屬性值」李四」傳給第二個參數
      $Person ->name = "小紅" ;   //賦值成功。若是沒有__set()，則出錯。
      //自動調用了__set()函數，將屬性名age傳給第一個參數，將屬性值26傳給第二個參數
      $Person ->age = 16; //賦值成功
      $Person ->age = 160; //160是一個非法值，賦值失效
      $Person ->say(); //輸出：我叫小紅，今年16歲了

      運行結果：

      我叫小紅，今年16歲了

      7、 __isset()，當對不可訪問屬性調用isset()或empty()時調用

      在看這個方法以前咱們看一下isset()函數的應用，isset()是測定變量是否設定用的函數，傳入一個變量做爲參數，若是傳入的變量存在則傳回true，不然傳回false。

      那麼若是在一個對象外面使用isset()這個函數去測定對象裏面的成員是否被設定可不能夠用它呢？

      分兩種狀況，若是對象裏面成員是公有的，咱們就可使用這個函數來測定成員屬性，若是是私有的成員屬性，這個函數就不起做用了，緣由就是由於私有的 被封裝了，在外部不可見。那麼咱們就不能夠在對象的外部使用isset()函數來測定私有成員屬性是否被設定了呢？固然是能夠的，但不是一成不變。你只要 在類裏面加上一個__isset()方法就能夠了，當在類外部使用isset()函數來測定對象裏面的私有成員是否被設定時，就會自動調用類裏面的 __isset()方法了幫咱們完成這樣的操做。

      __isset()的做用：當對不可訪問屬性調用 isset() 或 empty() 時，__isset() 會被調用。

      請看下面代碼演示：

      ?
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      28
      29
      <?php
      class Person
      {
         public $sex ;
         private $name ;
         private $age ;
       
         public function __construct( $name = "" , $age =25, $sex = '男' )
         {
           $this ->name = $name ;
           $this ->age = $age ;
           $this ->sex = $sex ;
         }
       
         /**
          * @param $content
          *
          * @return bool
          */
         public function __isset( $content ) {
           echo "當在類外部使用isset()函數測定私有成員{$content}時，自動調用<br>" ;
           echo isset( $this -> $content );
         }
      }
       
      $person = new Person( "小明" , 25); // 初始賦值
      echo isset( $person ->sex), "<br>" ;
      echo isset( $person ->name), "<br>" ;
      echo isset( $person ->age), "<br>" ;

      運行結果以下：

      1 // public 能夠 isset()
      當在類外部使用isset()函數測定私有成員name時，自動調用 // __isset() 內 第一個echo
      1 // __isset() 內第二個echo
      當在類外部使用isset()函數測定私有成員age時，自動調用 // __isset() 內 第一個echo
      1 // __isset() 內第二個echo

      8、 __unset()，當對不可訪問屬性調用unset()時被調用。

      看這個方法以前呢，咱們也先來看一下 unset() 函數，unset()這個函數的做用是刪除指定的變量且傳回true，參數爲要刪除的變量。

      那麼若是在一個對象外部去刪除對象內部的成員屬性用unset()函數能夠嗎？

      這裏天然也是分兩種狀況：

      一、 若是一個對象裏面的成員屬性是公有的，就可使用這個函數在對象外面刪除對象的公有屬性。

      二、 若是對象的成員屬性是私有的，我使用這個函數就沒有權限去刪除。

      雖然有以上兩種狀況，但我想說的是一樣若是你在一個對象裏面加上__unset()這個方法，就能夠在對象的外部去刪除對象的私有成員屬性了。在對 象裏面加上了__unset()這個方法以後，在對象外部使用「unset()」函數刪除對象內部的私有成員屬性時，對象會自動調用__unset()函 數來幫咱們刪除對象內部的私有成員屬性。

      請看以下代碼：

      ?
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      28
      29
      <?php
      class Person
      {
         public $sex ;
         private $name ;
         private $age ;
       
         public function __construct( $name = "" , $age =25, $sex = '男' )
         {
           $this ->name = $name ;
           $this ->age = $age ;
           $this ->sex = $sex ;
         }
       
         /**
          * @param $content
          *
          * @return bool
          */
         public function __unset( $content ) {
           echo "當在類外部使用unset()函數來刪除私有成員時自動調用的<br>" ;
           echo isset( $this -> $content );
         }
      }
       
      $person = new Person( "小明" , 25); // 初始賦值
      unset( $person ->sex);
      unset( $person ->name);
      unset( $person ->age);

      運行結果：

      當在類外部使用unset()函數來刪除私有成員時自動調用的
      1當在類外部使用unset()函數來刪除私有成員時自動調用的

      9、 __sleep()，執行serialize()時，先會調用這個函數

      serialize() 函數會檢查類中是否存在一個魔術方法 __sleep()。若是存在，則該方法會優先被調用，而後才執行序列化操做。

      此功能能夠用於清理對象，並返回一個包含對象中全部應被序列化的變量名稱的數組。

      若是該方法未返回任何內容，則 NULL 被序列化，併產生一個 E_NOTICE 級別的錯誤。

      注意：

      __sleep() 不能返回父類的私有成員的名字。這樣作會產生一個 E_NOTICE 級別的錯誤。能夠用 Serializable 接口來替代。
      做用：

      __sleep() 方法經常使用於提交未提交的數據，或相似的清理操做。同時，若是有一些很大的對象，但不須要所有保存，這個功能就很好用。

      具體請參考以下代碼：

      ?
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      <?php
      class Person
      {
         public $sex ;
         public $name ;
         public $age ;
       
         public function __construct( $name = "" , $age =25, $sex = '男' )
         {
           $this ->name = $name ;
           $this ->age = $age ;
           $this ->sex = $sex ;
         }
       
         /**
          * @return array
          */
         public function __sleep() {
           echo "當在類外部使用serialize()時會調用這裏的__sleep()方法<br>" ;
           $this ->name = base64_encode ( $this ->name);
           return array ( 'name' , 'age' ); // 這裏必須返回一個數值，裏邊的元素表示返回的屬性名稱
         }
      }
       
      $person = new Person( '小明' ); // 初始賦值
      echo serialize( $person );
      echo '<br/>' ;

      代碼運行結果：

      當在類外部使用serialize()時會調用這裏的__sleep()方法
      O:6:"Person":2:{s:4:"name";s:8:"5bCP5piO";s:3:"age";i:25;}

      10、 __wakeup()，執行unserialize()時，先會調用這個函數

      若是說 __sleep() 是白的，那麼 __wakeup() 就是黑的了。

      那麼爲何呢？

      由於：

      與之相反，`unserialize()` 會檢查是否存在一個 `__wakeup()` 方法。若是存在，則會先調用 `__wakeup` 方法，預先準備對象須要的資源。

      做用：

      __wakeup() 常常用在反序列化操做中，例如從新創建數據庫鏈接，或執行其它初始化操做。

      仍是看代碼：

      ?
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      28
      29
      30
      31
      32
      33
      34
      35
      36
      37
      <?php
      class Person
      {
         public $sex ;
         public $name ;
         public $age ;
       
         public function __construct( $name = "" , $age =25, $sex = '男' )
         {
           $this ->name = $name ;
           $this ->age = $age ;
           $this ->sex = $sex ;
         }
       
         /**
          * @return array
          */
         public function __sleep() {
           echo "當在類外部使用serialize()時會調用這裏的__sleep()方法<br>" ;
           $this ->name = base64_encode ( $this ->name);
           return array ( 'name' , 'age' ); // 這裏必須返回一個數值，裏邊的元素表示返回的屬性名稱
         }
       
         /**
          * __wakeup
          */
         public function __wakeup() {
           echo "當在類外部使用unserialize()時會調用這裏的__wakeup()方法<br>" ;
           $this ->name = 2;
           $this ->sex = '男' ;
           // 這裏不須要返回數組
         }
      }
       
      $person = new Person( '小明' ); // 初始賦值
      var_dump(serialize( $person ));
      var_dump(unserialize(serialize( $person )));

      運行結果：

      當在類外部使用serialize()時會調用這裏的__sleep()方法
      string(58) "O:6:"Person":2:{s:4:"name";s:8:"5bCP5piO";s:3:"age";i:25;}" 當在類外部使用serialize()時會調用這裏的__sleep()方法
      當在類外部使用unserialize()時會調用這裏的__wakeup()方法
      object(Person)#2 (3) { ["sex"]=> string(3) "男" ["name"]=> int(2) ["age"]=> int(25) }

      11、 __toString()，類被當成字符串時的迴應方法

      做用：

      __toString() 方法用於一個類被當成字符串時應怎樣迴應。例如 `echo $obj;` 應該顯示些什麼。

      注意：

      此方法必須返回一個字符串，不然將發出一條 `E_RECOVERABLE_ERROR` 級別的致命錯誤。

      警告：

      不能在 __toString() 方法中拋出異常。這麼作會致使致命錯誤。

      代碼：

      ?
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      <?php
      class Person
      {
         public $sex ;
         public $name ;
         public $age ;
       
         public function __construct( $name = "" , $age =25, $sex = '男' )
         {
           $this ->name = $name ;
           $this ->age = $age ;
           $this ->sex = $sex ;
         }
       
         public function __toString()
         {
           return 'go go go' ;
         }
      }
       
      $person = new Person( '小明' ); // 初始賦值
      echo $person ;

      結果：

      go go go

      那麼若是類中沒有 __toString() 這個魔術方法運行會發生什麼呢？讓咱們來測試下：

      代碼：

      ?
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      <?php
      class Person
      {
         public $sex ;
         public $name ;
         public $age ;
       
         public function __construct( $name = "" , $age =25, $sex = '男' )
         {
           $this ->name = $name ;
           $this ->age = $age ;
           $this ->sex = $sex ;
         }
         
      }
       
      $person = new Person( '小明' ); // 初始賦值
      echo $person ;

      結果：

      Catchable fatal error: Object of class Person could not be converted to string in D:\phpStudy\WWW\test\index.php on line 18
      很明顯，頁面報了一個致命錯誤，這是語法所不容許的。

      12、 __invoke()，調用函數的方式調用一個對象時的迴應方法

      做用：

      當嘗試以調用函數的方式調用一個對象時，__invoke() 方法會被自動調用。

      注意：

      本特性只在 PHP 5.3.0 及以上版本有效。

      直接上代碼：

      ?
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      <?php
      class Person
      {
         public $sex ;
         public $name ;
         public $age ;
       
         public function __construct( $name = "" , $age =25, $sex = '男' )
         {
           $this ->name = $name ;
           $this ->age = $age ;
           $this ->sex = $sex ;
         }
       
         public function __invoke() {
           echo '這但是一個對象哦' ;
         }
       
      }
       
      $person = new Person( '小明' ); // 初始賦值
      $person ();

      查看運行結果：

      這但是一個對象哦

      固然，若是你執意要將對象當函數方法使用，那麼會獲得下面結果：

      Fatal error: Function name must be a string in D:\phpStudy\WWW\test\index.php on line 18

      十3、 __set_state()，調用var_export()導出類時，此靜態方法會被調用。

      做用：

      自 PHP 5.1.0 起，當調用 var_export() 導出類時，此靜態方法會被自動調用。

      參數：

      本方法的惟一參數是一個數組，其中包含按 array('property' => value, ...) 格式排列的類屬性。

      下面咱們先來看看在沒有加 __set_state() 狀況按下，代碼及運行結果如何：

      上代碼：

      ?
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      <?php
      class Person
      {
         public $sex ;
         public $name ;
         public $age ;
       
         public function __construct( $name = "" , $age =25, $sex = '男' )
         {
           $this ->name = $name ;
           $this ->age = $age ;
           $this ->sex = $sex ;
         }
       
      }
       
      $person = new Person( '小明' ); // 初始賦值
      var_export( $person );

      看結果：

      Person::__set_state(array( 'sex' => '男', 'name' => '小明', 'age' => 25, ))

      很明顯，將對象中的屬性都打印出來了

      加了 __set_state() 以後：

      繼續上代碼：

      ?
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      <?php
      class Person
      {
         public $sex ;
         public $name ;
         public $age ;
       
         public function __construct( $name = "" , $age =25, $sex = '男' )
         {
           $this ->name = $name ;
           $this ->age = $age ;
           $this ->sex = $sex ;
         }
       
         public static function __set_state( $an_array )
         {
           $a = new Person();
           $a ->name = $an_array [ 'name' ];
           return $a ;
         }
       
      }
       
      $person = new Person( '小明' ); // 初始賦值
      $person ->name = '小紅' ;
      var_export( $person );

      繼續看結果：

      Person::__set_state(array( 'sex' => '男', 'name' => '小紅', 'age' => 25, ))

      十4、 __clone()，當對象複製完成時調用

      在多數狀況下，咱們並不須要徹底複製一個對象來得到其中屬性。但有一個狀況下確實須要：若是你有一個 GTK 窗口對象，該對象持有窗口相關的資源。你可能會想複製一個新的窗口，保持全部屬性與原來的窗口相同，但必須是一個新的對象（由於若是不是新的對象，那麼一 個窗口中的改變就會影響到另外一個窗口）。還有一種狀況：若是對象 A 中保存着對象 B 的引用，當你複製對象 A 時，你想其中使用的對象再也不是對象 B 而是 B 的一個副本，那麼你必須獲得對象 A 的一個副本。

      做用：

      對象複製能夠經過 clone 關鍵字來完成（若是可能，這將調用對象的 __clone() 方法）。對象中的 __clone() 方法不能被直接調用。

      語法：

      $copy_of_object = clone $object;

      注意：

      當對象被複制後，PHP 5 會對對象的全部屬性執行一個淺複製（shallow copy）。全部的引用屬性 仍然會是一個指向原來的變量的引用。

      當複製完成時，若是定義了 __clone() 方法，則新建立的對象（複製生成的對象）中的 __clone() 方法會被調用，可用於修改屬性的值（若是有必要的話）。
      看代碼：

      ?
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      28
      29
      <?php
      class Person
      {
         public $sex ;
         public $name ;
         public $age ;
       
         public function __construct( $name = "" , $age =25, $sex = '男' )
         {
           $this ->name = $name ;
           $this ->age = $age ;
           $this ->sex = $sex ;
         }
       
         public function __clone()
         {
           echo __METHOD__ . "你正在克隆對象<br>" ;
         }
       
      }
       
      $person = new Person( '小明' ); // 初始賦值
      $person2 = clone $person ;
       
      var_dump( 'persion1:' );
      var_dump( $person );
      echo '<br>' ;
      var_dump( 'persion2:' );
      var_dump( $person2 );

      看結果：

      Person::__clone你正在克隆對象
      string(9) "persion1:" object(Person)#1 (3) { ["sex"]=> string(3) "男" ["name"]=> string(6) "小明" ["age"]=> int(25) }
      string(9) "persion2:" object(Person)#2 (3) { ["sex"]=> string(3) "男" ["name"]=> string(6) "小明" ["age"]=> int(25) }

      克隆成功。

      十5、__autoload()，嘗試加載未定義的類

      做用：

      你能夠經過定義這個函數來啓用類的自動加載。

      在魔術函數 __autoload() 方法出現之前，若是你要在一個程序文件中實例化100個對象，那麼你必須用include或者require包含進來100個類文件，或者你把這100個類定義在同一個類文件中 —— 相信這個文件必定會很是大，而後你就痛苦了。

      可是有了 __autoload() 方法，之後就沒必要爲此大傷腦筋了，這個類會在你實例化對象以前自動加載制定的文件。

      仍是經過例子來看看吧：

      先看看以往的方式：

      ?
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      /**
        * 文件non_autoload.php
        */
         
      require_once ( 'project/class/A.php' );
      require_once ( 'project/class/B.php' );
      require_once ( 'project/class/C.php' );
         
      if (條件A) {
         $a = new A();
         $b = new B();
         $c = new C();
         // … 業務邏輯
      } else if (條件B) {
         $a = newA();
         $b = new B();
         // … 業務邏輯
      }

      看到了嗎？不用100個，只是3個看起來就有點煩了。並且這樣就會有一個問題：若是腳本執行「條件B」這個分支時，C.php這個文件其實沒有必要 包含。由於，任何一個被包含的文件，不管是否使用，均會被php引擎編譯。若是不使用，卻被編譯，這樣能夠被視做一種資源浪費。更進一步，若是C.php 包含了D.php，D.php包含了E.php。而且大部分狀況都執行「條件B」分支，那麼就會浪費一部分資源去編譯C.php,D.php,E.php 三個「無用」的文件。

      那麼若是使用 __autoload() 方式呢？

      ?
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      /**
        * 文件autoload_demo.php
        */
      function __autoload( $className ) {
         $filePath = 「project/ class /{ $className }.php」;
         if ( is_readable ( $filePath )) {
           require ( $filePath );
         }
      }
         
      if (條件A) {
         $a = new A();
         $b = new B();
         $c = new C();
         // … 業務邏輯
      } else if (條件B) {
         $a = newA();
         $b = new B();
         // … 業務邏輯
      }

      ok,不論效率怎麼用，最起碼界面看起來舒服多了，沒有太多冗餘的代。

      再來看看這裏的效率如何，咱們分析下：

      當php引擎第一次使用類A，可是找不到時，會自動調用 __autoload 方法，並將類名「A」做爲參數傳入。因此，咱們在 __autoload() 中須要的作的就是根據類名，找到相應的文件，幷包含進來，若是咱們的方法也找不到，那麼php引擎就會報錯了。

      注意：

      這裏能夠只用require，由於一旦包含進來後，php引擎再遇到類A時，將不會調用__autoload，而是直接使用內存中的類A，不會致使屢次包含。

      擴展：

      其實php發展到今天，已經有將 `spl_autoload_register` — 註冊給定的函數做爲 __autoload 的實現了，可是這個不在啊本文講解以內，有興趣能夠自行看手冊。

      十6、__debugInfo()，打印所需調試信息

      注意：

      該方法在PHP 5.6.0及其以上版本才能夠用，若是你發現使用無效或者報錯，請查看啊你的版本。

      看代碼：

      ?
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      <?php
      class C {
         private $prop ;
       
         public function __construct( $val ) {
           $this ->prop = $val ;
         }
       
         /**
          * @return array
          */
         public function __debugInfo() {
           return [
             'propSquared' => $this ->prop ** 2,
           ];
         }
      }
       
      var_dump( new C(42));

      結果：

      object(C)#1 (1) { ["propSquared"]=> int(1764) }

      再次注意：

      這裏的 `**` 是乘方的意思，也是在PHP5.6.0及其以上纔可使用，詳情請查看PHP手冊

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程