欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

深入理解 PHP 的 7 个预定义接口

程序员文章站 2022-03-25 21:38:39
深入理解预定义接口 场景:平常工作中写的都是业务模块,很少会去实现这样的接口,但是在框架里面用的倒是很多。 1. Traversable(遍历)接口 该接口不能被类直接实现,如果直接写了一个普通类实现了该遍历接口,是会直接报致命的错误,提示使用 Iterator(迭代器接口)或者 IteratorA ......

深入理解预定义接口

场景:平常工作中写的都是业务模块,很少会去实现这样的接口,但是在框架里面用的倒是很多。

 

1. traversable(遍历)接口

该接口不能被类直接实现,如果直接写了一个普通类实现了该遍历接口,是会直接报致命的错误,提示使用 iterator(迭代器接口)或者 iteratoraggregate(聚合迭代器接口)来实现,这两个接口后面会介绍;所有通常情况下,我们只是会用来判断该类是否可以使用 foreach 来进行遍历;

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 字符串;接下来是使用这个匿名类的方法,这两个方法的目的都是把匿名函数绑定一个类上使用;

  1. bindto()
 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()
 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 时,其实其中会有一个处理记忆体的过程,所以实际上这是一个用时间换空间的办法。

 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

上一篇: vbcrlf的意思

下一篇: 3-SQL过滤