这篇文章主要介绍了php遍历对象的方法，帮助大家更好的理解和学习使用php，感兴趣的朋友可以了解下。

目录

对于php来说，foreach是非常方便好用的一个语法，几乎对于每一个PHPer它都是日常接触最多的请求之一。那么对象是否能通过foreach来遍历呢？

答案是肯定的，但是有个条件，那就是对象的遍历只能获得它的公共属性。

1. // 普通遍历 
2. class A 
3. { 
4.     public $a1 = '1'; 
5.     public $a2 = '2'; 
6.     public $a3 = '3'; 
7.  
8.     private $a4 = '4'; 
9.     protected $a5 = '5'; 
10.  
11.     public $a6 = '6'; 
12.  
13.     public function test() 
14.     { 
15.         echo 'test'; 
16.     } 
17. } 
18. $a = new A(); 
19. foreach ($a as $k => $v) { 
20.     echo $k, '===', $v, PHP_EOL; 
21. } 
22.  
23. // a1===1 
24. // a2===2 
25. // a3===3 
26. // a6===6 

不管是方法还是受保护或者私有的变量，都无法遍历出来。只有公共的属性才能被遍历出来。其实，我们之前在讲设计模式时讲过的迭代器模式就是专门用来进行对象遍历的，而且PHP已经为我们准备好了相关的接口，我们只需要去实现这个接口就可以完成迭代器模式的创建了。具体的内容可以参考之前的设计模式系列文章：PHP设计模式之迭代器模式

1. // 实现迭代器接口 
2. class B implements Iterator 
3. { 
4.     private $var = []; 
5.  
6.     public function __construct($array) 
7.     { 
8.         if (is_array($array)) { 
9.             $this->var = $array; 
10.         } 
11.     } 
12.  
13.     public function rewind() 
14.     { 
15.         echo "rewinding\n"; 
16.         reset($this->var); 
17.     } 
18.  
19.     public function current() 
20.     { 
21.         $var = current($this->var); 
22.         echo "current: $var\n"; 
23.         return $var; 
24.     } 
25.  
26.     public function key() 
27.     { 
28.         $var = key($this->var); 
29.         echo "key: $var\n"; 
30.         return $var; 
31.     } 
32.  
33.     public function next() 
34.     { 
35.         $var = next($this->var); 
36.         echo "next: $var\n"; 
37.         return $var; 
38.     } 
39.  
40.     public function valid() 
41.     { 
42.         $var = $this->current() !== false; 
43.         echo "valid: {$var}\n"; 
44.         return $var; 
45.     } 
46. } 
47.  
48. $b = new B([1, 2, 3, 4]); 
49.  
50. foreach ($b as $k => $v) { 
51.     echo $k, '===', $v, PHP_EOL; 
52. } 
53.  
54. // rewinding 
55. // current: 1 
56. // valid: 1 
57. // current: 1 
58. // key: 0 
59. // 0===1 
60. // next: 2 
61. // current: 2 
62. // valid: 1 
63. // current: 2 
64. // key: 1 
65. // 1===2 
66. // next: 3 
67. // current: 3 
68. // valid: 1 
69. // current: 3 
70. // key: 2 
71. // 2===3 
72. // next: 4 
73. // current: 4 
74. // valid: 1 
75. // current: 4 
76. // key: 3 
77. // 3===4 
78. // next: 
79. // current: 
80. // valid: 

假如今天的文章只是讲之前讲过的迭代器模式，那就太没意思了，所以，咱们还要来学习一个更有意思的应用。那就是让对象可以像数组一样进行操作。这个其实也是使用PHP早已为我们准备好的一个接口：ArrayAccess。

1. // 让类可以像数组一样操作 
2. class C implements ArrayAccess, IteratorAggregate 
3. { 
4.     private $container = []; 
5.     public function __construct() 
6.     { 
7.         $this->container = [ 
8.             "one" => 1, 
9.             "two" => 2, 
10.             "three" => 3, 
11.         ]; 
12.     } 
13.     public function offsetSet($offset, $value) 
14.     { 
15.         if (is_null($offset)) { 
16.             $this->container[] = $value; 
17.         } else { 
18.             $this->container[$offset] = $value; 
19.         } 
20.     } 
21.     public function offsetExists($offset) 
22.     { 
23.         return isset($this->container[$offset]); 
24.     } 
25.     public function offsetUnset($offset) 
26.     { 
27.         unset($this->container[$offset]); 
28.     } 
29.     public function offsetGet($offset) 
30.     { 
31.         return isset($this->container[$offset]) ? $this->container[$offset] : null; 
32.     } 
33.  
34.     public function getIterator() { 
35.         return new B($this->container); 
36.     } 
37. } 
38.  
39. $c = new C(); 
40. var_dump($c); 
41.  
42. $c['four'] = 4; 
43. var_dump($c); 
44.  
45. $c[] = 5; 
46. $c[] = 6; 
47. var_dump($c); 
48.  
49. foreach($c as $k=>$v){ 
50.     echo $k, '===', $v, PHP_EOL; 
51. } 
52.  
53. // rewinding 
54. // current: 1 
55. // valid: 1 
56. // current: 1 
57. // key: one 
58. // one===1 
59. // next: 2 
60. // current: 2 
61. // valid: 1 
62. // current: 2 
63. // key: two 
64. // two===2 
65. // next: 3 
66. // current: 3 
67. // valid: 1 
68. // current: 3 
69. // key: three 
70. // three===3 
71. // next: 4 
72. // current: 4 
73. // valid: 1 
74. // current: 4 
75. // key: four 
76. // four===4 
77. // next: 5 
78. // current: 5 
79. // valid: 1 
80. // current: 5 
81. // key: 0 
82. // 0===5 
83. // next: 6 
84. // current: 6 
85. // valid: 1 
86. // current: 6 
87. // key: 1 
88. // 1===6 
89. // next:  
90. // current:  
91. // valid:  

这个接口需要我们实现四个方法：

offsetSet($offset, $value)，根据偏移量设置值

offsetExists($offset)，根据偏移量确定是否存在内容

offsetUnset($offset)，根据偏移量删除内容

offsetGet($offset)，根据依稀量获取内容

这里的偏移量就是我们常说的下标。通过实现这四个方法，我们就可以像操作数组一样的操作对象。当然，日常开发中我们可能并不会很经常的使用包括迭代器在内的这些对象遍历的能力。

通常我们会直接去将对象转换成数组 (array) obj 来进行下一步的操作。不过，在java中，特别是JavaBean中会经常在类的内部有一个 List 为自己的对象来表示自身的集合状态。

通过对比，我们发现PHP也完全可以实现这样的能力，而且使用迭代器和 ArrayAccess 接口还能够更方便的实现类似的能力。这是非常有用的一种知识扩展，或许下一个项目中你就能运用上这些能力哦！

测试代码：github.com/zhangyue050…

Tags: php遍历对象

分享到：