iterable 迭代器

iterable 迭代器

---

Traversable

Traversable用于检测一个类是否可以使用 foreach 进行遍历，这是一个无法在 PHP 脚本中实现的内部引擎接口，实际编程中我们使用Iterator接口或者IteratorAggregate接口来实现遍历。

Traversable 重要的一个用处就是判断一个类是否可以遍历，下面是官方例子：

if( !is_array( $items ) && !$items instanceof Traversable )  

需要注意的是，数组和对象可以通过foreach遍历，但它们没有实现Traversable接口，所以不是Traversable的示例：

$array=[1,2,3];  
$obj = (object) $array;  
var_dump($array instanceof \Traversable);   //false
var_dump($obj instanceof \Traversable); //false  

类未实现Iterator接口或者IteratorAggregate接口时，执行foreach遍历将输出所有其能够访问的可见属性。

未实现Iterator接口或者IteratorAggregate接口时，执行foreach遍历将输出所有其能够访问的可见属性和私有的内部属性。

Iterator

Iterator接口的作用是允许对象以自己的方式迭代内部的数据，从而使它可以被循环访问，Iterator接口摘要如下：

Iterator extends Traversable {  
    //返回当前索引游标指向的元素  
    abstract public mixed current ( void )  
    //返回当前索引游标指向的键  
    abstract public scalar key ( void )  
    //移动当前索引游标到下一元素  
    abstract public void next ( void )  
    //重置索引游标  
    abstract public void rewind ( void )  
    //判断当前索引游标指向的元素是否有效  
    abstract public boolean valid ( void )  
}  

当一个实现了Iterator接口的对象，被foreach遍历时，会自动调用这些方法。调用的循序是：
rewind() -> valid() -> current() -> key() -> next()

下面是一个简单的例子演示Iterator的使用方法：

/** 
 * 该类允许外部迭代自己内部私有属性$_test，并演示迭代过程 
 * 
 * @author 疯狂老司机 
 */  
class TestIterator implements Iterator {  

    /* 
     * 定义要进行迭代的数组 
     */  
    private $_test = array('dog', 'cat', 'pig');  

    /* 
     * 索引游标 
     */  
    private $_key = 0;  

    /* 
     * 执行步骤 
     */  
    private $_step = 0;  

    /** 
     * 将索引游标指向初始位置 
     * 
     * @see TestIterator::rewind() 
     */  
    public function rewind() {  
        echo '第'.++$this->_step.'步：执行 '.__METHOD__.'<br>';  
        $this->_key = 0;  
    }  

    /** 
     * 判断当前索引游标指向的元素是否设置 
     * 
     * @see TestIterator::valid() 
     * @return bool 
     */  
    public function valid() {  
        echo '第'.++$this->_step.'步：执行 '.__METHOD__.'<br>';  
        return isset($this->_test[$this->_key]);  
    }  

    /** 
     * 将当前索引指向下一位置 
     * 
     * @see TestIterator::next() 
     */  
    public function next() {  
        echo '第'.++$this->_step.'步：执行 '.__METHOD__.'<br>';  
        $this->_key++;  
    }  
    /** 
     * 返回当前索引游标指向的元素的值 
     * 
     * @see TestIterator::current() 
     * @return value 
     */  
    public function current() {  
        echo '第'.++$this->_step.'步：执行 '.__METHOD__.'<br>';  
        return $this->_test[$this->_key];  
    }  

    /** 
     * 返回当前索引值 
     * 
     * @return key 
     * @see TestIterator::key() 
     */  
    public function key() {  
        echo '第'.++$this->_step.'步：执行 '.__METHOD__.'<br>';  
        return $this->_key;  
    }  
}  

foreach 循环

$iterator = new TestIterator();  
foreach($iterator as $key => $value){ 
    var_dump("输出索引为{$key}的元素".":$value");  
    echo '---------------------------'."\n";
} 

上面输出结果

以上例子将输出：
第1步：执行 TestIterator::rewind
第2步：执行 TestIterator::valid
第3步：执行 TestIterator::current
第4步：执行 TestIterator::key
输出索引为0的元素:dog

第5步：执行 TestIterator::next
第6步：执行 TestIterator::valid
第7步：执行 TestIterator::current
第8步：执行 TestIterator::key
输出索引为1的元素:cat

第9步：执行 TestIterator::next
第10步：执行 TestIterator::valid
第11步：执行 TestIterator::current
第12步：执行 TestIterator::key
输出索引为2的元素:pig

第13步：执行 TestIterator::next
第14步：执行 TestIterator::valid

从以上例子可以看出，如果执行valid返回false，则循环就此结束。

当一个实现了Iterator接口的对象，被foreach遍历时，会自动调用这些方法。
调用的循序是： rewind() -> valid() -> current() -> key() -> next()

- rewind() 只在最开始执行一次
- valid（） 验证，返回ture时继续执行 next()；返回false，退出执行
- current() foreach 遍历时输出 value 值
- key()  foreach 遍历时输出 key 值
- next() 当valid() 返回true 时候执行



$iterator = new TestIterator();  
foreach($iterator as $key => $value){ 
    var_dump("输出索引为{$key}的元素".":$value");  
    echo '---------------------------'."\n";
} 

结果：

foreach 遍历对象出来的 {key} 为 Iterator@key()方法的返回值
        {value} 为 Iterator@current()方法的返回值

为了验证我们上面我们的结果：我们可以把 key()、current() 返回值修改

key()  方法里面修改成：retrun time();

current() 方法里面修改成：return '======';

我们会发现 foreach 时输出的 key/value 都为我们刚修改的返回值

继续测试， valid() 把该函数里面的代码修改成

$count = 0;
while($count < 5)
{
    return false;
}
会发现，foreach 只会循环输出5次，可见 valid 返回 false,循环就停止了

这种迭代器缺点：
1. 实现的函数比较多（5个）
2. 上面说到，如果某一索引下没有值，则就此中断了，不在循环。如果上面的迭代数组为

private $_test = array('dog', 'cat', 'pig', 8=> 'bird');  

由于游标下标是自增的，到了 2->pig 时，自增为 3 ,匹配不到索引值中断，导致bird的值无法输出。

解决上面的缺点，不实现接口Iterator，实现他的子接口IteratorAggregate

IteratorAggregate

IteratorAggregate又叫聚合式迭代器，它提供了创建外部迭代器的接口，接口摘要如下：

IteratorAggregate extends Traversable {  
    abstract public Traversable getIterator ( void )  
}  

实现getIterator方法时必须返回一个实现了Iterator接口的类的实例。

/** 
 * 利用聚合式迭代器，并返回一个实现了Iterator接口的类的实例 
 * 
 * @author 疯狂老司机 
 */  
class myData implements IteratorAggregate {  
    public $one = "Public property one";  
    public $two = "Public property two";  
    public $three = "Public property three";  

    public function __construct() {  
        $this->last = "last property";  
    }  

    public function getIterator() {  
        return new ArrayIterator($this);  
    }  
}  

$obj = new myData;  

foreach($obj as $key => $value) {  
    var_dump($key, $value);  
    echo '<br>';// Linux：echo "\n";  
} 

以上例程的输出类似于：

string(9) "property1"
string(19) "Public property one"

string(9) "property2"
string(19) "Public property two"

string(9) "property3"
string(21) "Public property three"

string(9) "property4"
string(13) "last property"

相比Iterator接口（实现5个方法），这个接口只需要实现一个方法（getIterator），解决了缺点1，
解决第二个缺点，这就需要我们来完善MyIterator，保证当索引不连续时，也能输出后面的值。封装的思想啊，大家尝试下吧。

我们说了Iterator ,IteratorAggregate , 在说下 Traversable

raversable接口，这个接口中什么样的抽样方法都没有，他是Iterator的父接口。最底层的，这个接口一般不会去实现它，如果非得要实现它，记住两点。

1、必须和Iterator、IteratorAggregate两个接口中的某一个或者两个一起用。

2、IteratorAggregate或者Iterator必须放在Traversable前面。如：class MyIterator implements Iterator,Traversable{}。切记。

最后总结：

ArrayIterator迭代器会把对象或数组封装为一个可以通过foreach来操作的类，具体SPL 迭代器后面会具体介绍

类未实现Iterator接口或者IteratorAggregate接口时，执行foreach遍历将输出所有其能够访问的可见属性，但不能遍历不可见的属性