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__.'
'
; $this->_key = 0; } /** * 判断当前索引游标指向的元素是否设置 * * @see TestIterator::valid() * @return bool */ public function valid() { echo '第'.++$this->_step.'步:执行 '.__METHOD__.'
'
; return isset($this->_test[$this->_key]); } /** * 将当前索引指向下一位置 * * @see TestIterator::next() */ public function next() { echo '第'.++$this->_step.'步:执行 '.__METHOD__.'
'
; $this->_key++; } /** * 返回当前索引游标指向的元素的值 * * @see TestIterator::current() * @return value */ public function current() { echo '第'.++$this->_step.'步:执行 '.__METHOD__.'
'
; return $this->_test[$this->_key]; } /** * 返回当前索引值 * * @return key * @see TestIterator::key() */ public function key() { echo '第'.++$this->_step.'步:执行 '.__METHOD__.'
'
; 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 '
'
;// 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遍历将输出所有其能够访问的可见属性,但不能遍历不可见的属性

你可能感兴趣的:(PHP)