深刻理解 PHP 的 7 個預約義接口

時間  2019-11-15
標籤 深刻 理解 php 預約 接口 欄目 PHP 简体版
原文   原文鏈接

深刻理解預約義接口

場景：日常工做中寫的都是業務模塊，不多會去實現這樣的接口，可是在框架裏面用的卻是不少。php

 

1. Traversable（遍歷）接口

該接口不能被類直接實現，若是直接寫了一個普通類實現了該遍歷接口，是會直接報致命的錯誤，提示使用 Iterator（迭代器接口）或者 IteratorAggregate（聚合迭代器接口）來實現，這兩個接口後面會介紹；全部一般狀況下，咱們只是會用來判斷該類是否可使用 foreach 來進行遍歷；shell

1    class Test implements Traversable
2     {
3     }
4     上面這個是錯誤示範，該代碼會提示這樣的錯誤：
5     Fatal error: Class Test must implement interface Traversable as part of either Iterator or 
6     IteratorAggregate in Unknown on line 0
 上面的大體意思是說如要實現這個接口，必須同Iterator或者IteratorAggregate來實現 正確的作法： 當咱們要判斷一個類是否可使用foreach來進行遍歷，只須要判斷是不是traversable的實例
1     class Test
2     {
3     }
4     $test = new Test;
5     var_dump($test instanceOf Traversable);
 

2. Iterator（迭代器）接口
 

 
 
迭代器接口其實實現的原理就是相似指針的移動，當咱們寫一個類的時候，經過實現對應的 5 個方法：key（），current（），next（），rewind（），valid（），就能夠實現數據的迭代移動，具體看如下代碼數組
 

 

 
 
 1 <?php
 2     class Test implements Iterator
 3     {
 4         private $key;
 5         private $val = [
 6             'one',
 7             'two',
 8             'three',
 9         ];
10 
11         public function key()
12         {
13             return $this->key;
14         }
15 
16         public function current()
17         {
18             return $this->val[$this->key];
19         }
20 
21         public function next()
22         {
23             ++$this->key;
24         }
25 
26         public function rewind()
27         {
28             $this->key = 0;
29         }
30 
31         public function valid()
32         {
33             return isset($this->val[$this->key]);
34         }
35     }
36 
37     $test = new Test;
38 
39     $test->rewind();
40 
41     while($test->valid()) {
42         echo $test->key . ':' . $test->current() . PHP_EOL;
43         $test->next();
44     }
 

 

 ## 該輸出結果 ： 0: one 1: two 2: three 看了這個原理咱們就知道，其實迭代的移動方式：rewind（）-> valid（）->key() -> current() -> next() -> valid（）-> key() ....-> valid(); 好的，理解了上面，咱們打開Iterator的接口，發現它是實現了Traversable（遍歷）接口的，接下來咱們來證實下： var_dump($test instanceOf Traversable); 結果返回的是true，證實這個類的對象是能夠進行遍歷的。
 

 
 
1 foreach （$test as $key => $value）{
2         echo $test->key . ':' . $test->current() . PHP_EOL;
3  }
 

 

 這個的結果跟while循環實現的模式是同樣的。
 


    

 

3. IteratorAggregate（聚合迭代器） 接口
 

 
 
聚合迭代器和迭代器的原理是同樣的，只不過聚合迭代器已經實現了迭代器原理，你只須要實現一個 getIterator（）方法來實現迭代，具體看如下代碼閉包
 

 

 
 
 1 <?php
 2     class Test implements IteratorAggregate
 3     {
 4         public $one = 1;
 5         public $two = 2;
 6         public $three = 3;
 7 
 8         public function __construct()
 9         {
10             $this->four = 4;
11         }
12 
13         public function getIterator()
14         {
15             return new AraayIterator($this);
16         }
17     }
18 
19     $test = (new Test())->getIterator();
20     $test->rewind();
21     while($test->valid()) {
22         echo $test->key() . ' : '  .  $test->current() . PHP_EOL;
23         $test->next();
24     }
25 
26     從上面的代碼，咱們能夠看到咱們將Test類的對象傳進去當作迭代器，經過while循環的話，咱們必須經過調用getIterator（）方法獲取到迭代器對象，而後直接進行迭代輸出，而不須要去實現相關的key()等方法。
27     固然這個時候，咱們確定想知道是否能夠直接從foreach進行迭代循環出去呢？那麼咱們來打印一下結果
28 
29     $test = new Test;
30     var_dump($test instanceOf Traversable);
31 
32     結果是輸出bool true，因此咱們接下來是直接用foreach來實現一下。
33 
34     $test = new Test;
35   foreach($test as $key => $value) {
36      echo $key . ' : ' . $value  .  PHP_EOL;
37   }
38 
39  接下來，咱們看到是對對象進行迭代，這個時候咱們是否能夠數組進行迭代呢？
40 
41  class Test implements IteratorAggregate
42  {
43     public $data;
44 
45     public function __construct()
46     {
47         $this->data = [''one' =>  1 , 'two' => 2];
48     }
49 
50     public function getIterator()
51     {
52         return new AraayIterator($this->data);
53     }
54  }
55 
56  同理實現的方式跟對對象進行迭代是同樣的。
57  
 

 

 
 

4. ArrayAccess（數組式訪問）接口
 

 
 
一般狀況下，咱們會看到 this ['name'] 這樣的用法，可是咱們知道，$this 是一個對象，是如何使用數組方式訪問的？答案就是實現了數據組訪問接口 ArrayAccess，具體代碼以下框架
 

 

 
 
 1 <?php
 2     class Test implements ArrayAccess
 3     {
 4         public $container;
 5 
 6         public function __construct()
 7         {
 8             $this->container = [
 9                 'one' => 1,
10                 'two' => 2,
11                 'three'  => 3,
12             ];
13         }
14 
15         public function offsetExists($offset) 
16         {
17             return isset($this->container[$offset]);
18         }
19 
20         public function offsetGet($offset)
21         {
22             return isset($this->container[$offset]) ? $this->container[$offset] : null;
23         }
24 
25         public function offsetSet($offset, $value)
26         {
27             if (is_null($offset)) {
28                 $this->container[] = $value;
29             } else {
30                 $this->container[$offset] = $value;
31             }
32         }
33 
34         public function offsetUnset($offset)
35         {
36             unset($this->container[$offset]);
37         }
38     }
39    $test = new Test;
40    var_dump(isset($test['one']));
41    var_dump($test['two']);
42    unset($test['two']);
43    var_dump(isset($test['two']));
44    $test['two'] = 22;
45    var_dump($test['two']);
46    $test[] = 4;
47    var_dump($test);
48    var_dump($test[0]);
49 
50    固然咱們也有經典的一個作法就是把對象的屬性當作數組來訪問
51 
52    class Test implements ArrayAccess
53    {
54         public $name;
55 
56         public function __construct()
57         {
58             $this->name = 'gabe';  
59         }
60 
61         public function offsetExists($offset)
62         {
63             return isset($this->$offset);
64         }
65 
66         public function offsetGet($offset)
67         {
68             return isset($this->$offset) ? $this->$offset : null;
69         }
70 
71         public function offsetSet($offset, $value)
72         {
73             $this->$offset = $value;
74         }
75 
76         public function offsetUnset($offset)
77         {
78             unset($this->$offset);
79         }
80    }
81 
82   $test = new Test;
83   var_dump(isset($test['name']));
84   var_dump($test['name']);
85   var_dump($test['age']);
86   $test[1] = '22';
87   var_dump($test);
88   unset($test['name']);
89   var_dump(isset($test['name']));
90   var_dump($test);
91   $test[] = 'hello world';
92   var_dump($test);
93  
 

 

 
 

5. Serializable （序列化）接口
 

 
 
一般狀況下，若是咱們的類中定義了魔術方法，sleep(),wakeup () 的話，咱們在進行 serialize () 的時候，會先調用 sleep () 的魔術方法，咱們經過返回一個數組，來定義對對象的哪些屬性進行序列化，同理，咱們在調用反序列化 unserialize () 方法的時候，也會先調用的 wakeup（）魔術方法，咱們能夠進行初始化，如對一個對象的屬性進行賦值等操做；可是若是該類實現了序列化接口，咱們就必須實現 serialize（）方法和 unserialize () 方法，同時 sleep（）和 wakeup () 兩個魔術方法都會同時再也不支持，具體代碼看以下；函數
 

 

 
 
 1 <?php
 2     class Test
 3     {    
 4         public $name;
 5         public $age;
 6 
 7         public function __construct()
 8         {
 9             $this->name = 'gabe';
10             $this->age = 25; 
11         }    
12 
13         public function __wakeup()
14         {
15             var_dump(__METHOD__); 
16             $this->age++;
17         }   
18 
19         public function __sleep()
20         {        
21             var_dump(__METHOD__);
22             return ['name'];    
23         }
24     }
25 
26     $test = new Test;
27     $a = serialize($test);
28     var_dump($a);
29     var_dump(unserialize($a));
30 
31     //實現序列化接口，發現魔術方法失效了
32 
33    class Test implements Serializable
34    {    
35     public $name;
36     public $age;
37 
38     public function __construct()
39     {        
40         $this->name = 'gabe';
41         $this->age = 25;
42     } 
43 
44     public function __wakeup()
45     { 
46         var_dump(__METHOD__);
47         $this->age++;
48     }
49 
50     public function __sleep()
51     {
52         var_dump(__METHOD__);
53         return ['name'];
54     }
55 
56     public function serialize()
57     {
58         return serialize($this->name);
59     } 
60 
61     public function unserialize($serialized)
62     {       
63         $this->name = unserialize($serialized);
64         $this->age = 1;    
65     }
66 }
67 $test = new Test;
68 $a = serialize($test);
69 var_dump($a);
70 var_dump(unserialize($a));
71  
 

 

 
 

6. Closure 類
 

 
 
用於表明匿名函數的類，凡是匿名函數其實返回的都是 Closure 閉包類的一個實例，該類中主要有兩個方法，bindTo（）和 bind（），經過查看源碼，能夠發現兩個方法是異曲同工，只不過是 bind () 是個靜態方法，具體用法看以下；大數據
 

 

 
 
1 <?php
2     $closure = function () {
3         return 'hello world';
4     }
5 
6     var_dump($closure);
7     var_dump($closure());
 

 

 
 

 
 
經過上面的例子，能夠看出第一個打印出來的是 Closure 的一個實例，而第二個就是打印出匿名函數返回的 hello world 字符串；接下來是使用這個匿名類的方法，這兩個方法的目的都是把匿名函數綁定一個類上使用；this
 
 
     
  
  1. bindTo()
    2.  
 
 

 

 
 
 1 <?php
 2 namespace demo1;
 3     class Test {
 4         private $name = 'hello woeld';
 5     }
 6 
 7     $closure = function () {
 8         return $this->name;
 9     }
10 
11     $func = $closure->bindTo(new Test);
12     $func();
13     // 這個是能夠訪問不到私有屬性的，會報出沒法訪問私有屬性
14     // 下面這個是正確的作法
15     $func = $closure->bindTo(new Test, Test::class);
16     $func();
17 
18 namespace demo2;
19     class Test
20     {
21         private statis $name = 'hello world';
22     }
23 
24     $closure = function () {
25         return self::$name;
26     }
27     $func = $closure->bindTo(null, Test::class);
28     $func();
 

 

 
 

 
 
     
  
  1. bind()
    2.  
 
 

 

 
 
 1 <?php
 2 namespace demo1;
 3 class Test 
 4 {
 5     private  $name = 'hello world';
 6 }
 7 
 8 $func = \Closure::bind(function() {
 9     return $this->name;
10 }, new Test, Test::class);
11 
12 $func();
13 
14 namespace demo2;
15 class Test 
16 {
17     private static  $name = 'hello world';
18 }
19 
20 $func = \Closure::bind(function() {
21     return self::$name;
22 }, null, Test::class);
23 
24 $func()
 

 

 
 


    

 

7. Generator （生成器）
 

 
 
Generator 實現了 Iterator，可是他沒法被繼承，同時也生成實例。既然實現了 Iterator，因此正如上文所介紹，他也就有了和 Iterator 相同的功能:rewind->valid->current->key->next...，Generator 的語法主要來自於關鍵字 yield。yield 就比如一次循環的中轉站，記錄本次的活動軌跡，返回一個 Generator 的實例。Generator 的優勢在於，當咱們要使用到大數據的遍歷，或者說大文件的讀寫，而咱們的內存不夠的狀況下，可以極大的減小咱們對於內存的消耗，由於傳統的遍歷會返回全部的數據，這個數據存在內存上，而 yield 只會返回當前的值，不過當咱們在使用 yield 時，其實其中會有一個處理記憶體的過程，因此實際上這是一個用時間換空間的辦法。spa
 

 

 
 
 1 <?php
 2 $start_time = microtime(true);
 3 function xrange(int $num){
 4     for($i = 0; $i < $num; $i++) { 
 5         yield $i;    
 6     }
 7 }
 8 $generator = xrange(100000);
 9 foreach ($generator as $key => $value) { 
10     echo $key . ': ' . $value . PHP_EOL;
11 }
12 echo 'memory: ' . memory_get_usage() . ' time: '. (microtime(true) - $start_time);
 

 

 
 

 
 
輸出：memory: 388904 time: 0.12135100364685指針
 

 

 
 
 1 <?php
 2 $start_time = microtime(true);
 3 function xrange(int $num){
 4     $arr = [];    
 5     for($i = 0; $i < $num; $i++) { 
 6         array_push($arr, $i);
 7     } 
 8     return $arr;
 9 }
10 $arr = xrange(100000);
11 foreach ($arr as $key => $value) {
12     echo $key . ': ' . $value . PHP_EOL;
13 }
14 echo 'memory: ' . memory_get_usage() . ' time: '. (microtime(true) - $start_time);
 

 

 
 

 
 
輸出：memory: 6680312 time: 0.10804104804993
 



        

            

        	





    

		

            
相關文章

            

                

                

                    

                

            


            
相關標籤/搜索

            
        


    

        

            

        

        

        
        

        

        

    




	

    





    

    	

    

        每日一句
    

    
    
    	每一个你不满意的现在，都有一个你没有努力的曾经。
    







    

    


    



    

        本站公眾號
    

    

           歡迎關注本站公眾號,獲取更多信息

        
    




    

    




	


	







    

        聯繫我們
        最近搜索
        最新文章
        
        沪ICP备13005482号-10

            MyBatis教程
            SQL 教程
            MySQL教程
            Java 教程
            Thymeleaf 教程
            Hibernate教程
            Spring教程 
            Redis教程