SPL中的迭代器详解

最新推荐文章于 2024-01-13 01:02:25 发布
最新推荐文章于 2024-01-13 01:02:25 发布
阅读量146 收藏
点赞数
文章标签： php 设计模式 c/c++
原文链接：http://www.cnblogs.com/caixw/archive/2010/07/28/intro-to-spl-iterator.htm
版权

介绍

迭代器这种设计模式很常见，也很实用。最著名的要算是C++中STL的实现了。它提供了一个统一的接口，使用访问者在不知道类对象内部数据结构的情况下遍历其内部数据。PHP5中提供了对这种设计模式的内置支持，其实所谓的内置支持就是可以使用foreach语言结构来访问实现迭代器接口的类。

一个简单的自定义迭代器

首先看一下下面这三段代码：

$array = array('a', 'b', 'c');
while($a = next($array))
{
    // do something
}
$dh = opendir('/home/test/files');
while(false !== ($file = readdir($dh)))
{
    // do something
}
$fh = fopen("/home/test/files/results.txt", "r");
while(!feof($fh))
{
   $line = fgets($fh);
   // do something
}

以上这三段代码虽然操作的资源(resource)各不相同，但是其功能是一样的，都是遍历资源中的数据。但是这三段代码却用了三套不同的函数，这些函数拥有不同的参数，不同的行为，我们在使用之前必须要了解其用途，才能写出一段遍历某种资源(resource)的代码。

迭代器设计模式就是在这种情况下产生：我们将其中的一些相同的操作抽象出来形成一个接口，不同的资源只要实现这一接口，就能以相同的方式遍历其中的数据。以下是一个简单迭代器接口的实现，在以PHP5之前，迭代器一般也是按照这种方式实现的。当然真实的代码中会比这更加复杂和健壮些。

interface SimpleIterator
{
    public function next();
    public function current();
}
class ArrayIterator implements SimpleIterator
{
    private $_data;
    public function __construct(array $data)
    {    $this->_data = $data;    }
    public function next()
    {    return next($this->_data);    }
    public function current()
    {    return current($this->_data);    }
}
class DirIterator implements SimpleIterator
{
    private $_handle;
    private $_current;
    public function __construct($path)
    {    $this->_handle = opendir($path);    }
    publi function next()
    {
         $this->_current = readdir($this->_handle);
         return false === $this->_current;
    }
    public function current()
    {    return $this->_current;    }
    public function __destruct()
    {    closedir($this->_handle);    }
}
class FileIterator implements SimpleIterator
{
    private $_handle;
    private $_line;
    public function __construct($file, $mode = 'r')
    {    $this->_handle = fopen($file, $mode);    }
    public function next()
    {
         if(feof($this->_handle))
         {    return false;    }
         $this->_line = fgets($this->_handle);
         return true;
    }
    public function current()
    {    return $this->_line;    }
    public function __destruct()
    {    fclose($this->_handle);    }
}
/* 以相同的接口遍历不同资源的数据 */
$arrayIter = new ArrayIterator(array('a','b','c'));
while($arrayIter->next())
{    echo $arrayIter->current();    }
$dirIter = new DirIterator('/home/test/files/')
while($dirIter->next())
{    echo $dirIter->current();    }
$fileIter = new FileIterator('/home/test/fiels/results.txt', 'r');
while($fileIter->next())
{    echo $fileIter->current();    }

SPL中的iterator接口

上面这种自定义实现的迭代器接口有一个缺点，就是不能用于foreach语句。而SPL中提供的iterator却实现了对foreach的支持。

interface Iterator extends Traversable
{
   // 将迭代器的指针移向第一个元素。类似于数组操作函数reset()。
   function rewind();
   // 类似于数组操作函数current()。返回迭代的当前元素。
   function current();
   // 返回当前迭代器元素的键名，类似于数组操作函数key()。
   function key();
   // 将指针移向迭代器的下一个元素，类似于数组操作函数next()。
   function next();
   // 检测在执行了rewind()或是next()函数之后，当前值是否是一个有效的值。
   function valid();
}

这就是SPL的迭代器接口，Traversable是Zend引擎的内置接口，它才是真正让类能用于foreach语句的接口，但是在PHP中并不能直接实现Traversable。只能间接地通过Iterator或IteratorAggregate接口实现。下面我们通过两个简单的例子看看如何实现Iterator接口的，虽然有点多余，但有时候代码住住比文字更能说明问题。

class ArrayIterator implements Iterator
{
    private $_data;
    private $_valid;
    public function __construct(array $data)
    {    $this->_data = $data;    }
    public function rewind()
    {    $this->_valid = rewind($this->_data;);    }
    public function current()
    {    return current($this->_data);    }
    public function key()
    {    return key($this->_data);    }
    public function next()
    {    $this->_valid = next($this->_data);    }
    public function valid()
    {    return $this->_valid;    }
}
class DirIterator implements Iterator
{
    private $_handle;
    private $_current;
    public function __construct($dir)
    {    $this->_handle = opendir($dir);    }
    public function rewind()
    {
        rewinddir($this->_handle);
        $this->next();
    }
    public function current()
    {    return $this->_current;    }
    public function key()
    {    return $this->_current;    }
    public function next()
    {    $this->_current = readdir($this->_handle);    }
    public function valid()
    {    return false !== $this->_current;    }
}
$dirIter = new DirIterator('/home/test/files');
foreach($dirIter as $key=>$dir)
{   echo $key,'====>',$dir,'<br />';    }
/* 或者用while的形式 */
$dirIter->rewind();
while($dirIter->valid())
{
    echo $dirIter->key(), '====>', $dirIter->current(), '<br />';
    $dirIter->next();
}

上面这段代码将会输出：

.====>.
..====>..
dir1====>dir1
dir2====>dir2
file2.txt====>file2.txt

相对于while语句，foreach语句隐藏了各函数的调用情况，使人不甚了解其具体调用情况，但是我们只要稍微写点代码就能对其调用情况了如指掌：

class TestIterator implements Iterator
{
    private $_count = 1;
    public function rewind()
    {
        echo 'rewind 
';
        $this->_count = 1;
    }
    public function current()
    {   echo 'current ', $this->_count, '<br />';   }
    public function key()
    {    echo 'key ', $this->_count, '<br />';    }
    public function next()
    {
        echo 'next<br />';
        $this->_count++;
    }
    public function valid()
    {
        echo 'valid<br />';
        return $this->_count <= 5;
    }
}
$test = new TestIterator();
foreach($test as $k=>$v)
{   // todo;
}

不难发现：

  1. foreach在执行前会调用对象的rewind()函数，确保每次都是从头开始。
  2. 之后会调用valid()函数确保值是否有效。
  3. 然后调用key()和current()将值赋给$key和$dir。
  4. 之后执行循环体，然后调用next()进入下一轮循环。

递归迭代器(RecursiveIterator)

这也是一种很常见的迭代器，SPL中也为其定义了一个接口：

interface RecursiveIterator extends Iterator
{
    // 是否存在子元素
    function hasChildren();
    // 获取子元素的迭代器
    function getChildren();
}

我们依旧以上面的DirIterator类为例，实现一个递归的迭代器。因为RecursiveIterator也是从Iterator继承而来的，所以我们的递归类也不用从头开始写，只须从DirIterator继承再实现RecursiveIterator接口的两个特有函数即可：

class RecursiveDirIterator extends DirIterator implements RecursiveIterator
{
    private $_path;
    public function __construct($path)
    {
        parent::__construct($path);
        $this->_path = $path;
    }
    public function hasChildren()
    {
        $c = $this->current();
        // 需要过滤掉 '.'和'..'目录
        return (is_dir($this->_path . DIRECTORY_SEPARATOR . $c) && $c != '.' && $c !='..');
    }
    public function getChildren()
    {
        return new RecursiveDirIterator($this->_path . DIRECTORY_SEPARATOR . $this->current());
    }
}
$rdi = new RecursiveDirIterator('/home/test/files');
foreach($rdi as $k=>$v)
{   echo $k,'===>',$v,'
'; }

IteratorAggergate接口

IteratorAggergate是除Iterator之外另一个从Traversable接口中继承而来的。其接口也很简单，只有一个函数。就是返回一个迭代器实例：

interface IteratorAggergate extends Traversable
{
    public function getIterator();
}

该接口的功能也是让实现者拥有迭代器的功能。初看之下，貌似没什么特别的，我们完全可以用Iterator接口来替代。事实上也是如此。之所以提供该类只不过是让我们少写点代码和减少类与类之间的耦合度。

我们依旧以DirIterator为例。假设有一个类A包含了一个私有成员DirIterator，而类A本身又要实现DirIterator的迭代器功能。按照我们之前的作法，会让类A实现Iterator接口，然后在各接口函数重写一次DirIterator的内容。但是这样做，若是后期将DirIterator更改为RecursiveDirIterator，则同时需要更改类A的接口，以符合要求。而用IteratorAggergate则不会出现这种情况。

class A implements IteratorAggergate
{
    private $_dirIter;
    public function __construct()
    {   $this->_dirIter = new DirIterator('/home/test/files');    }
    // 返回一个迭代。
    public function getIterator()
    {    return $this->_dirIter;    }
}
$a = new A();
$iter = $a->getIterator();
while($iter->valid())
{
    // do something
}
// foreach 能识别IteratorAggergate接口，并取得迭代器，进入循环。
foreach($a as $v)
{
    // do something
}

OuterIterator

interface OuterIterator extends Iterator
{
    public function getInnerIterator();
}

OuterIterator相当于我们前一节讲的类A的另一种实现。它实现者可以包含一个或多个迭代器成员，即可以通过getInnerIterator()接口函数获取内部的迭代器，也可以直接通过类本身实现的Iterator接口遍历内部的迭代器数据。这在SPL是一个非常重要的接口，SPL中很多内置的迭代器实现了这个接口。

FilterIterator

FilterIterator这是一个抽象类，它实现了OuterIterator接口。它包装一个已有的迭代器类，通过抽象方法accept()过滤掉不需要的内容，形成一个新的迭代器。我们还是用上面的DirIterator作一个例子，定义一个只返回所有以'a'开头的目录名的迭代器：

class ADirIterator extends FilterIterator
{
    public function accept()
    {
        return 0 === strpos($this->current(), 'a');
    }
}
$dirIter = new DirIter('/home/test/files');
$adirIter = new ADirIter($dirIter);
foreach($adirITer as $dir)
{    /* todo */    }

LimitIterator

这也是一个实现OuterIterator的类。它有点类似于SQL中的LIMIT语句。它通过包装一个已有迭代器，然后截取其中某一段数据形成一个新的迭代器。它同时还提供了两个函数：
getPosition()：当前迭代器的位置。
seek($pos)：直接跳到某个位置的元素。 

$data = array('a','d','c','f','g');
$offset = 2;
$count = 3;
$limitData = new LimitIterator(new ArrayIterator($data), $offset, $count);
foreach($limitData as $v)
{
    echo $limitData->getPosition(), ':', $v, '<br />';
}
try{
     $limitData->seek(4);
}catch(exception $e)
{    echo $e->getMessage();    }

遍历对象属性

当我们对一个没有实现iterator接口的对象使用foreach时，它会依次访问对象的公共(public)属性，这是一个非常棒的机制：

class Test
{
    public $p1 = 1;
    public $p2 = 2;
    protected $p3 = 3;
    protected $p4 = 4;
    private $p5 = 5;
    private $p6 = 6;
}
$t = new Test();
foreach($t as $property=>$value)
{    echo $property,'====>',$value,'<br />';    }

上例中会显示出$p1,$p2的属性。而$p3,$p4,$p5,$p6则因为访问权限问题无法列出。若想要列出被保护的成员，只需将foreach移到类内即可：

class Test
{
    public $p1 = 1;
    public $p2 = 2;
    protected $p3 = 3;
    protected $p4 = 4;
    private $p5 = 5;
    private $p6 = 6;
    public function properties()
    {
        foreach($this as $property=>$value)
        {    echo $property,'====>',$value,'<br />';    }
    }
}

SPL中一些已实现的迭代器类

在SPL中已经定义了一非常有用的迭代器类，我们可以直接拿来用：

  • DirectoyIterator: 和我们上面实现的DirIterator类大同小异。但是功能更全
  • RecursiveDirectoryIterator：依旧和我们上面实现的RecursiveDirIterator类很相似。
  • SimpleXMLIterator：一个遍历XML内容的类，关于它的信息网站信息多得不得了。这里也不做介绍了。但使用它的时候有一点需要注意，具体情况看这里。
  • IteratorIterator：实现对迭代器的包装，这也是SPL中对OuterIterator默认实现。
  • NoRewindIterator：取消了rewind()函数的迭代器。
  • InfiniteIterator：从字面意思就知道，这是个无限循环的迭代器，当next()到达最后时，会自动调用rewind()函数，又从头开始。
  • AppendIterator：它实现了对一系统迭代器的包装，并且可以在运行过程中添加新的迭代器。
  • SplFileObject：文件操作类，可以按行的方式遍历文件内容。同时还能获取文件的大小及其它详细信息。

参考

Introducing PHP 5's Standard Library

Iterators in PHP5

本文采用 知识共享署名-非商业性使用-相同方式共享 2.5 中国大陆许可协议 进行许可。
转载时请注明出处：https://caixw.io/posts/2010/spl-iterator.html

转载于:https://www.cnblogs.com/caixw/archive/2010/07/28/intro-to-spl-iterator.html

SPL学习笔记之二：迭代器
LAMP随记
09-14 1158
<br />SPL迭代器接口的作用在于帮助实现高级的迭代算法，允许为类创建精巧的数据访问方法。<br />SPL提供了5个迭代器接口：Traversable、Iterator、IteratorAggregate、OuterIterator和RecursiveIterator。<br />1. Traversable：Traversable接口实际上不是一个接口，而更像是一个特性。这是因为只有内部的类（也就是用C语言编写的类）才可以直接实现Traversable接口。有两个派生自Traversable接口的基
SPL学习笔记之一：SPL简介
LAMP随记
09-14 2186
      SPL（标准PHP库）是PHP5面向对象功能中最重要的组成部分。它在5个关键的方面提升了PHP语言，包括：迭代器、异常、数组重载、XML以及文件和数据处理能力。它还提供了另外一些有用的项，例如观察者模式、计数功能、用于对象标识符的辅助函数以及迭代器处理功能。此外，它还提供了用于自动加载类和接口的高级功能。      在引擎层次，SPL实现了提供所有高级功能的6个类和接口。这些接口了Exception类都具有特殊性，即它们实际上与传统的接口不同。它们拥有特别强大的功能，并且允许引擎以一种特定且特殊
SPL的常用迭代器（3）
琉忆编程库
03-03 393
1.迭代器的介绍 ·什么是迭代器？  -怎样获得链表中的每一个节点信息   节点1节点2节点3   ↑链表指针 通过某种统一的方式遍历链表或者数组中的元素的过程 叫做迭代遍历，而这种统一的遍历工具我们叫做迭代器 ·PHP中迭代器是通过Iterator接口定义的   节点1节点2节点3   ↑current(); 2.ArrayIterator迭代器 ·Arra
spl应用场景 -- IteratorIterator迭代器
bkduck的专栏
07-25 3114
spl应用场景 – IteratorIterator迭代器1.介绍##改迭代器接口，主要可以 “迭代” 迭代器， 例如 ArrayIterator 类结构如下： “`php IteratorIteratorimplements OuterIterator {/* 方法 */public __construct ( Traversable $iterator )public mixed cur
mysql迭代器_迭代器是什么，C++ STL迭代器（iterator）用法详解
weixin_35750747的博客
02-02 282
无论是序列容器还是关联容器，最常做的操作无疑是遍历容器中存储的元素，而实现此操作，多数情况会选用“迭代器(iterator)”来实现。那么，迭代器到底是什么呢？我们知道，尽管不同容器的内部结构各异，但它们本质上都是用来存储大量数据的，换句话说，都是一串能存储多个数据的存储单元。因此，诸如数据的排序、查找、求和等需要对数据进行遍历的操作方法应该是类似的。既然类似，完全可以利用泛型技术，将它们设计成适...
迭代器 iterator
qq_443996319的博客
09-20 392
ArrayList arr = new ArrayList(); Iterator it = arr.iterator(); while( it .hasNext() ){  //做一些处理，比如  System.out.print( it.next ); } next(),  是返回当前元素， 并指向下一个元素。 hasNext()， 则是判断当前元素是否存在，并指向下一个元素（即
基于PHP的SPL常用数据结构与迭代器设计源码详解
最新发布
09-28
PHP SPL (Standard PHP Library) 是PHP的一个扩展库，...通过深入解析这些文件，开发者可以更深刻地理解 PHP SPL 库中数据结构和迭代器的内部工作原理，以及如何在实际编程中有效地使用这些工具来优化代码结构和性能。
PHP中spl_autoload_register()函数用法实例详解
12-19
SPL（Standard PHP Library）是PHP5引入的一个标准库，包含了多种功能，如迭代器、比较器、堆栈、队列、图等。其中，SPL 自动加载机制是通过将函数指针 `autoload_func` 指向自定义的自动加载函数来实现的。SPL 提供...
PHP SPL标准库接口详解：Countable, OuterIterator, RecursiveIterator等
它通常与其他迭代器结合使用，以便在迭代过程中提供更复杂的行为。`IteratorIterator`是OuterIterator的一个实现示例，可以修改或包装其他迭代器的行为。在上述代码中，创建了一个`MyOuterIterator`类，扩展了`...
PHP中spl_autoload_register()函数用法实例详解_.docx
10-09
SPL扩展提供了许多其他有用的功能，如迭代器、堆栈、队列等，以及更多用于自动加载的接口和类，如` spl_autoload_functions()`用于获取当前注册的自动加载函数，`spl_autoload_unregister()`用于从自动加载栈中移除...
从join的实现窥探MySQL迭代器
GreatSQL2021的博客
09-15 348
以如下left join查询语句为范例： select * from t1 left join t2 on t1.c=t2.a ;以下初始化数据： 1 DROP TABLE IF EXISTS `t1`; 2 CREATE TABLE `t1` ( 3 `a` int DEFAULT NULL, 4 `b` varchar(20) DEFAULT NULL 5 ) 6 INSERT INTO `t1` VALUES (1, 'a'); 7 INS
周五轻松修复老项目Bug，加入迭代器和SQL联合查询优化，提升代码质量！
m0_46464597的博客
01-13 422
通过合并查询，减少了代码冗余，提高了代码的可维护性。学到了在使用UNION ALL时处理排序的技巧，通过在子查询内部添加ORDER BY并封装为命名的子查询解决了问题。
Php-SPL库中的迭代器类详解
MMMMM
06-05 2751
SPL提供了多个迭代器类，分别提供了迭代访问、过滤数据、缓存结果、控制分页等功能。，因为php总是在不断壮大，我尽可能列出SPL中所有的迭代类。下面其中一些迭代器类是需要php5.4，另外一些如SearhIteratoer类在最新的php版本中已经去除 1.ArrayIteratoer 从PHP数组创建一个迭代器，当其和IteratorAggregate类一起使用时，免去了直接实现Iterat
标准库类型基础（3）— 迭代器iterator
Echo Lab
03-16 498
术语iterator往往表示两个不同的事物。一般意义上是迭代器的意思；具体而言指的是由容器定义的具体的iterator类型，如vector。若一种类型支持一组确定的操作（这些操作可以用来遍历容器内的元素，并访问，或修改这些元素的值），就称之为迭代器。 就这个概念而言，可以将数组类比于容器，那么指针就是数组的迭代器（这只是类别，并不准确）。这里放在一起简单的介绍。 用迭代器的方式重新编写
迭代器Iterator基本用法--集合遍历
CROSSFIT的博客
08-19 6376
欢迎使用Markdown编辑器写博客 本Markdown编辑器使用StackEdit修改而来，用它写博客，将会带来全新的体验哦： Markdown和扩展Markdown简洁的语法 代码块高亮 图片链接和图片上传 LaTex数学公式 UML序列图和流程图 离线写博客 导入导出Markdown文件 丰富的快捷键 快捷键 加粗 Ctrl + B 斜体 Ctrl + I...
迭代器（Iterator）详解
热门推荐
尽力而为
09-17 1万+
迭代器（Iterator ）的实际运用远比我预想的要多，有必要深入了解一下
迭代器Iterator用法
m1234ilu的博客
10-22 709
HsahSet set=new HashSet();
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值