今天小编就为大家分享一篇关于PHP标准库(PHP SPL)详解，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧

什么是SPL？

SPL，PHP 标准库（Standard PHP Library） ，此从 PHP 5.0 起内置的组件和接口，并且从 PHP5.3 已逐渐的成熟。SPL 其实在所有的 PHP5 开发环境中被内置，同时无需任何设置。

似乎众多的 PHP 开发人员基本没有使用它，甚至闻所未闻。究其原因，可以追述到它那阳春白雪般的说明文档，使你忽略了「它的存在」。SPL 这块宝石犹如铁达尼的「海洋之心」般，被沉入海底。而现在它应该被我们捞起，并将它穿戴在应有的位置 ，而这也是这篇文章所要表述的观点。

那么，SPL 提供了什么？

SPL 对 PHP 引擎进行了扩展，例如 ArrayAccess、Countable 和 SeekableIterator 等接口，它们用于以数组形式操作对象。同时，你还可以使用 RecursiveIterator、ArrayObejcts 等其他迭代器进行数据的迭代操作。

它还内置几个的对象例如 Exceptions、SplObserver、Spltorage 以及 splautoloadregister、splclasses、iteratorapply 等的帮助函数（helper functions），用于重载对应的功能。

这些工具聚合在一起就好比是把多功能的瑞士军刀，善用它们可以从质上提升 PHP 的代码效率。那么，我们如何发挥它的威力？

如何使用SPL？

SPL提供了一组标准数据结构：

双向链表

SplDoublyLinkedList

SplStack

SplQueue

双链表是一种重要的线性存储结构，对于双链表中的每个节点，不仅仅存储自己的信息，还要保存前驱和后继节点的地址。

PHP SPL中的SplDoublyLinkedList类提供了对双链表的操作。

SplDoublyLinkedList类摘要如下：

1. SplDoublyLinkedList implements Iterator , ArrayAccess , Countable {  
2.  public __construct ( void ) 
3.  public void add ( mixed $index , mixed $newval ) 
4.  //双链表的头部节点 
5.  public mixed top ( void ) 
6.  //双链表的尾部节点 
7.  public mixed bottom ( void ) 
8.  //双联表元素的个数 
9.  public int count ( void ) 
10.  //检测双链表是否为空 
11.  public bool isEmpty ( void ) 
12.  //当前节点索引 
13.  public mixed key ( void ) 
14.  //移到上条记录 
15.  public void prev ( void ) 
16.  //移到下条记录 
17.  public void next ( void ) 
18.  //当前记录 
19.  public mixed current ( void ) 
20.  //将指针指向迭代开始处 
21.  public void rewind ( void ) 
22.  //检查双链表是否还有节点 
23.  public bool valid ( void )   
24.  //指定index处节点是否存在 
25.  public bool offsetExists ( mixed $index ) 
26.  //获取指定index处节点值 
27.  public mixed offsetGet ( mixed $index ) 
28.  //设置指定index处值 
29.  public void offsetSet ( mixed $index , mixed $newval ) 
30.  //删除指定index处节点 
31.  public void offsetUnset ( mixed $index )  
32.  //从双链表的尾部弹出元素 
33.  public mixed pop ( void ) 
34.  //添加元素到双链表的尾部 
35.  public void push ( mixed $value )   
36.  //序列化存储 
37.  public string serialize ( void ) 
38.  //反序列化 
39.  public void unserialize ( string $serialized ) 
40.  //设置迭代模式 
41.  public void setIteratorMode ( int $mode ) 
42.  //获取迭代模式SplDoublyLinkedList::IT_MODE_LIFO (Stack style) SplDoublyLinkedList::IT_MODE_FIFO (Queue style) 
43.  public int getIteratorMode ( void ) 
44.  //双链表的头部移除元素 
45.  public mixed shift ( void ) 
46.  //双链表的头部添加元素 
47.  public void unshift ( mixed $value ) 
48. } 

使用起来也比较简单

1. $list = new SplDoublyLinkedList(); 
2.  $list->push('a'); 
3.  $list->push('b'); 
4.  $list->push('c'); 
5.  $list->push('d');  
6.  $list->unshift('top'); 
7.  $list->shift();  
8.  $list->rewind();//rewind操作用于把节点指针指向Bottom所在的节点 
9.  echo 'curren node:'.$list->current()."<br />";//获取当前节点 
10.  $list->next();//指针指向下一个节点 
11.  echo 'next node:'.$list->current()."<br />"; 
12.  $list->next(); 
13.  $list->next(); 
14.  $list->prev();//指针指向上一个节点 
15.  echo 'next node:'.$list->current()."<br />"; 
16.  if($list->current()) 
17.    echo 'current node is valid<br />'; 
18.  else 
19.    echo 'current node is invalid<br />'; 
20.  if($list->valid())//如果当前节点是有效节点，valid返回true 
21.    echo "valid list<br />"; 
22.  else 
23.    echo "invalid list <br />"; 
24.  var_dump(array( 
25.    'pop' => $list->pop(), 
26.    'count' => $list->count(), 
27.    'isEmpty' => $list->isEmpty(), 
28.    'bottom' => $list->bottom(), 
29.    'top' => $list->top() 
30.  )); 
31.  $list->setIteratorMode(SplDoublyLinkedList::IT_MODE_FIFO); 
32.  var_dump($list->getIteratorMode()); 
33.  for($list->rewind(); $list->valid(); $list->next()) { 
34.    echo $list->current().PHP_EOL; 
35.  } 
36.  var_dump($a = $list->serialize()); 
37.  //print_r($list->unserialize($a)); 
38.  $list->offsetSet(0,'new one'); 
39.  $list->offsetUnset(0); 
40.  var_dump(array( 
41.    'offsetExists' => $list->offsetExists(4), 
42.    'offsetGet' => $list->offsetGet(0), 
43.  )); 
44.  var_dump($list); 
45.  //堆栈，先进后出 
46.  $stack = new SplStack();//继承自SplDoublyLinkedList类 
47.  $stack->push("a<br />"); 
48.  $stack->push("b<br />"); 
49.  echo $stack->pop(); 
50.  echo $stack->pop(); 
51.  echo $stack->offsetSet(0,'B');//堆栈的offset=0是Top所在的位置，offset=1是Top位置节点靠近bottom位置的相邻节点，以此类推 
52.  $stack->rewind();//双向链表的rewind和堆栈的rewind相反，堆栈的rewind使得当前指针指向Top所在的位置，而双向链表调用之后指向bottom所在位置 
53.  echo 'current:'.$stack->current().'<br />'; 
54.  $stack->next();//堆栈的next操作使指针指向靠近bottom位置的下一个节点，而双向链表是靠近top的下一个节点 
55.  echo 'current:'.$stack->current().'<br />'; 
56.  echo '<br /><br />'; 
57.  //队列，先进先出 
58.  $queue = new SplQueue();//继承自SplDoublyLinkedList类 
59.  $queue->enqueue("a<br />");//插入一个节点到队列里面的Top位置 
60.  $queue->enqueue("b<br />"); 
61.  $queue->offsetSet(0,'A');//堆栈的offset=0是Top所在的位置，offset=1是Top位置节点靠近bottom位置的相邻节点，以此类推 
62.  echo $queue->dequeue(); 
63.  echo $queue->dequeue(); 
64.  echo "<br /><br />"; 

重载 autoloader

如果你是位「教科书式的程序员」，那么你保证了解如何使用 __autoload 去代替 includes/requires 操作惰性载入对应的类，对不？

但久之，你会发现你已经陷入了困境，首先是你要保证你的类文件必须在指定的文件路径中，例如在 Zend 框架中你必须使用「_」来分割类、方法名称（你如何解决这一问题？）。

另外的一个问题，就是当项目变得越来越复杂， __autoload 内的逻辑也会变得相应的复杂。到最后，甚至你会加入异常判断，以及将所有的载入类的逻辑如数写到其中。

大家都知道「鸡蛋不能放到一个篮子中」，利用 SPL 可以分离 __autoload 的载入逻辑。只需要写个你自己的 autoload 函数，然后利用 SPL 提供的函数重载它。

例如上述 Zend 框架的问题，你可以重载 Zend loader 对应的方法，如果它没有找到对应的类，那么就使用你先前定义的函数。

1. <?php 
2. class MyLoader { 
3.   public static function doAutoload($class) { 
4.     // 本模块对应的 autoload 操作 
5.   } 
6. } 
7. spl_autoload_register( array('MyLoader', 'doAutoload') ); 
8. ?> 

正如你所见， spl autoload register 还能以数组的形式加入多个载入逻辑。同时，你还可以利用spl autoload unregister 移除已经不再需要的载入逻辑，这功能总会用到的。

迭代器

迭代是常见设计模式之一，普遍应用于一组数据中的统一的遍历操作。可以毫不夸张的说，SPL 提供了所有你需要的对应数据类型的迭代器。

有个非常好的案例就是遍历目录。常规的做法就是使用 scandir ，然后跳过「.「 和 「..」，以及其它未满足条件的文件。例如你需要遍历个某个目录抽取其中的图片文件，就需要判断是否是 jpg、gif 结尾。

下面的代码就是使用 SPL 的迭代器执行上述递归寻找指定目录中的图片文件的例子：

1. <?php 
2. class RecursiveFileFilterIterator extends FilterIterator { 
3.   // 满足条件的扩展名 
4.   protected $ext = array('jpg','gif'); 
5.   /** 
6.    * 提供 $path 并生成对应的目录迭代器 
7.    */ 
8.   public function __construct($path) { 
9.     parent::__construct(new RecursiveIteratorIterator(new RecursiveDirectoryIterator($path))); 
10.   } 
11.   /** 
12.    * 检查文件扩展名是否满足条件 
13.    */ 
14.   public function accept() { 
15.     $item = $this->getInnerIterator(); 
16.     if ($item->isFile() &&  
17.         in_array(pathinfo($item->getFilename(), PATHINFO_EXTENSION), $this->ext)) { 
18.       return TRUE; 
19.     } 
20.   } 
21. } 
22. // 实例化 
23. foreach (new RecursiveFileFilterIterator('/path/to/something') as $item) { 
24.   echo $item . PHP_EOL; 
25. } 
26. ?> 

你可能会说，这不是花了更多的代码去办同一件事情吗？那么，查看上面的代码，你不是拥有了具有高度重用而且可以测试的代码了吗 :)

下面是 SPL 提供的其他的迭代器：

1. RecursiveIterator 
2. RecursiveIteratorIterator 
3. OuterIterator 
4. IteratorIterator 
5. FilterIterator 
6. RecursiveFilterIterator 
7. ParentIterator 
8. SeekableIterator 
9. LimitIterator 
10. GlobIterator 
11. CachingIterator 
12. RecursiveCachingIterator 
13. NoRewindIterator 
14. AppendIterator 
15. RecursiveIteratorIterator 
16. InfiniteIterator 
17. RegexIterator 
18. RecursiveRegexIterator 
19. EmptyIterator 
20. RecursiveTreeIterator 
21. ArrayIterator 

自 PHP5.3 开始，会内置其他更多的迭代器，我想你都可以尝试下，或许它能改变你编写传统代码的习惯。

SplFixedArray

SPL 还内置了一系列的数组操作工具，例如可以使用 SplFixedArray 实例化一个固定长度的数组。那么为什么要使用它？因为它更快，甚至它关系着你的工资问题 :)

我们知道 PHP 常规的数组包含不同类型的键，例如数字、字符串等，并且长度是可变的。正是因为这些「高级功能」，PHP 以散列（hash）的方式通过键得到对应的值 -- 其实这在特定情况这会造成性能问题。

而 SplFixedArray 因为是使用固定的数字键，所以它并没有使用散列存储方式。不确切的说，甚至你可以认为它就是个 C 数组。这就是为什么 SplFixedArray 会比通常数组要快的原因（仅在 PHP5.3 中）。

那到底有多快呢，下面的组数据可以让你窥其究竟。

如果你需要大量的数组操作，那么你可以尝试下，相信它是值得信赖的。

数据结构

同时 SPL 还提供了些数据结构基本类型的实现 。虽然我们可以使用传统的变量类型来描述数据结构，例如用数组来描述堆栈（Strack）-- 然后使用对应的方式 pop 和 push（arraypop()、arraypush()），但你得时刻小心，·因为毕竟它们不是专门用于描述数据结构的 -- 一次误操作就有可能破坏该堆栈。

而 SPL 的 SplStack 对象则严格以堆栈的形式描述数据，并提供对应的方法。同时，这样的代码应该也能理解它在操作堆栈而非某个数组，从而能让你的同伴更好的理解相应的代码，并且它更快。

最后，可能上述那些惨白的例子还不足矣「诱惑你」去使用 SPL。实践出真知，SPL 更多、更强大的功能需要你自己去挖掘。而它正如宝石般的慢慢雕砌，才能散发光辉。

Tags: PHP标准库 SPL

分享到：