程序员人生 网站导航

PHP数组的高级遍历和操作处理方法

栏目：php教程时间：2013-11-09 03:13:03

前面我讲过简单的数组遍历,这些基于foreach,for之类的语句,下面我来介绍数组的高级遍历方法介绍,各位朋友可参考,这些数组才真用于开发实用性能强,复杂也更高了.

PHP对数组的处理可以称为该语言最有吸引力的特性之一,它支持70多种数组相关的函数,不论你想翻转一个数组、判断某个值在数组中是否存在、将数组转换成一个字符串还是计算数组的大小，仅仅执行一个现有的函数就可以完成。然而也有一些数组相关的任务对开发者的要求就较高，仅仅知道手册有某个功能是不能解决的，这些任务就需要对PHP的原始特性有一些深入的理解，还需要一些解决问题的想象力。

多维关联数组排序

PHP提供了一些数组排序的函数，比如sort(), ksort()，和asort()，但是却没有提供对多维关联数组的排序。

比如这样的数组：

  1. Array 
  2. ( 
  3.   [0] => Array 
  4.     ( 
  5.       [name] => chess 
  6.       [price] => 12.99 
  7.     ) 
  8.   [1] => Array 
  9.     ( 
  10.       [name] => checkers 
  11.       [price] => 9.99 
  12.     ) 
  13.   [2] => Array 
  14.     ( 
  15.       [name] => backgammon 
  16.       [price] => 29.99 
  17.     ) 
  18. ) 

要将该数组按照升序排序,你需要自己写一个函数用于比较价格,然后将该函数作为回调函数传递给usort()函数来实现该功能,代码如下:

  1. function comparePrice($priceA, $priceB){ 
  2.     return $priceA['price'] - $priceB['price']; 
  3. } 
  4. usort($games, 'comparePrice'); 

执行了该程序片段,数组就会被排序,结果如下所示:

  1. Array 
  2. ( 
  3.   [0] => Array 
  4.     ( 
  5.       [name] => checkers 
  6.       [price] => 9.99 
  7.     ) 
  8.   [1] => Array 
  9.     ( 
  10.       [name] => chess 
  11.       [price] => 12.99 
  12.     ) 
  13.   [2] => Array 
  14.     ( 
  15.       [name] => backgammon 
  16.       [price] => 29.99 
  17.     ) 
  18. ) 

要将该数组按照降序排序,把comparePrice()函数里面的两个减的数调换位置就可以了.

逆序遍历数组

PHP的While循环和For循环是遍历一个数组最常用的方法,但是你怎样遍历像下面这个数组呢？

  1. Array 
  2. ( 
  3.   [0] => Array 
  4.     ( 
  5.       [name] => Board 
  6.       [games] => Array 
  7.         ( 
  8.           [0] => Array 
  9.             ( 
  10.               [name] => chess 
  11.               [price] => 12.99 
  12.             ) 
  13.           [1] => Array 
  14.             ( 
  15.               [name] => checkers 
  16.               [price] => 9.99 
  17.             ) 
  18.         ) 
  19.     ) 
  20. ) 

PHP标准库中有一个对集合的迭代器iterators类,它不仅仅能够用于遍历一些异构的数据结构(比如文件系统和数据库查询结果集),也可以对一些不知道大小的嵌套数组的遍历,比如对上面的数组的遍历,可以使用RecursiveArrayIterator迭代器进行,代码如下:

  1. $iterator = new RecursiveArrayIterator($games);  
  2. iterator_apply($iterator, 'navigateArray', array($iterator)); 
  3. function navigateArray($iterator) {  
  4.  while ($iterator->valid()) {  
  5.   if ($iterator->hasChildren()) {  
  6.    navigateArray($iterator->getChildren());  
  7.   } else {  
  8.    printf("%s: %s", $iterator->key(), $iterator->current()); 
  9.   }  
  10.   $iterator->next();  
  11.  }   
  12. } 

执行该段代码会给出以下的结果：

name: Board

name: chess

price: 12.99

name: checkers

price: 9.99

过滤关联数组的结果

假定你得到了如下一个数组,但是你仅仅想操作价格低于$11.99的元素：

  1. Array 
  2. ( 
  3.   [0] => Array 
  4.     ( 
  5.       [name] => checkers 
  6.       [price] => 9.99 
  7.     ) 
  8.   [1] => Array 
  9.     ( 
  10.       [name] => chess 
  11.       [price] => 12.99 
  12.     ) 
  13.   [2] => Array 
  14.     ( 
  15.       [name] => backgammon 
  16.       [price] => 29.99 
  17.     ) 
  18. ) 

使用array_reduce()函数可以很简单的实现,代码如下:

  1. function filterGames($game){ 
  2.  return ($game['price'] < 11.99); 
  3. } 
  4. $names = array_filter($games, 'filterGames'); 

array_reduce()函数会过滤掉不满足回调函数的所有的元素,本例子的回调函数就是filterGames,任何价格低于11.99的元素会被留下,其他的会被剔除,该代码段的执行结果：

  1. Array 
  2. ( 
  3.   [1] => Array 
  4.     ( 
  5.       [name] => checkers 
  6.       [price] => 9.99 
  7.     ) 
  8. ) 

对象转换成数组

一个需求就是将对象转换成数组形式,方法比你想象的简单很多,仅仅强制转换就可以了,实例代码如下:

  1. class Game { 
  2.  public $name; 
  3.  public $price; 
  4. } 
  5. $game = new Game(); 
  6. $game->name = 'chess'; 
  7. $game->price = 12.99; 
  8. print_r(array($game)); 

执行该例子就会产生如下结果：

  1. Array 
  2. ( 
  3. [0] => Game Object 
  4.   ( 
  5.     [name] => chess 
  6.     [price] => 12.99 
  7.   ) 
  8. ) 

将对象转换成数组会出现一些不可预料的副作用,比如上面的代码段,所有的成员变量都是public类型的,但是对于private私有变量的返回结果会变得不一样,下面是另外一个例子,代码如下:

  1. class Game { 
  2.  public $name; 
  3.  private $_price; 
  4.  public function setPrice($price)  { 
  5.   $this->_price = $price; 
  6.  } 
  7. } 
  8. $game = new Game(); 
  9. $game->name = 'chess'; 
  10. $game->setPrice(12.99); 
  11. print_r(array($game));执行该代码片段： 
  12. Array 
  13. ( 
  14. [0] => Game Object 
  15.   ( 
  16.     [name] => chess 
  17.     [_price:Game:private] => 12.99 
  18.   ) 
  19. ) 

正如你所看到的,为了进行区分,数组中保存的私有变量的key被自动改变了。

数组的“自然排序”

PHP对于“字母数字”字符串的排序结果是不确定的,举个例子,假定你有很多图片名称存放于数组中,代码如下:

  1. $arr = array( 
  2.  0=>'madden2011.png', 
  3.  1=>'madden2011-1.png', 
  4.  2=>'madden2011-2.png', 
  5.  3=>'madden2012.png' 
  6. ); 

你怎样对这个数组进行排序呢？如果你用sort()对该数组排序,结果是这样的：

  1. Array 
  2. ( 
  3.     [0] => madden2011-1.png 
  4.     [1] => madden2011-2.png 
  5.     [2] => madden2011.png 
  6.     [3] => madden2012.png 
  7. ) 

有时候这就是我们想要的,但是我们想保留原来的下标怎么办？解决该问题可以使用natsort()函数,该函数用一种自然的方法对数组排序,代码如下:

  1. <?php 
  2. $arr = array( 
  3.  0=>'madden2011.png', 
  4.  1=>'madden2011-1.png', 
  5.  2=>'madden2011-2.png', 
  6.  3=>'madden2012.png' 
  7. ); 
  8. natsort($arr); 
  9. echo "<pre>"; print_r($arr); echo "</pre>"; 
  10. ?> 

运行结果：

  1. Array 
  2. ( 
  3.     [1] => madden2011-1.png 
  4.     [2] => madden2011-2.png 
  5.     [0] => madden2011.png 
  6.     [3] => madden2012.png 
  7. ) 

遍历过程中的改值操作

引用操作符&

看下面这段代码中的$array数组,在foreach循环时对$value使用引用操作符,这样在循环中修改$value的值的时候,便将$array中对应的元素值修改了,代码如下:

  1. <?php 
  2. $array = array("A"=>1, "B"=>1, "C"=>1, "D"=>1); 
  3. foreach($array as &amp;$value) 
  4.     $value = 2; 
  5. print_r($array); 
  6. ?> 

上段代码的输出如下：

Array ( [A] => 2 [B] => 2 [C] => 2 [D] => 2 ) 

可以看到，$array中各个键对应的值都被修改成了2。看来这种方法确实奏效。

利用键值操作数组的元素

有的时候,数组中表示的可能是一些互相关联的元素,如果遇到了这些相互关联的元素中的一个,就将其他元素做一个标记的话,上面的引用肯定就不管用了,这时候修改这些关联元素的时候,就要使用其对应的键值了,先试试看管用不,代码如下:

  1. <?php 
  2. $array = array("A"=>1, "B"=>1, "C"=>1, "D"=>1); 
  3. foreach($array as $key => $value){ 
  4.     if($key == "B"){ 
  5.         $array["A"] = "CHANGE"; 
  6.         $array["D"] = "CHANGE"; 
  7.         print_r($array); 
  8.         echo '<br />'; 
  9.     } 
  10.  
  11.     if($value === "CHANGE") 
  12.         echo $value.'<br />'; 
  13. } 
  14. print_r($array); 
  15. ?> 

别着急看输出,我们想象中的应该是什么样呢？打印修改后的数组,打印一个“CHANGE”,再打印一遍修改后的数组,对吗？来看一下输出吧！

Array ( [A] => CHANGE [B] => 1 [C] => 1 [D] => CHANGE )

Array ( [A] => CHANGE [B] => 1 [C] => 1 [D] => CHANGE ) 

咦？怎么个情况？我们的CHANGE哪去了？

按照我们的想法,既然$array已经改变了,那么当遍历到键值为“D”的元素时,应当输出它的新值“CHANGE”才对！可是事实并不是我们想的那样,PHP在这里做了什么手脚呢？把上面的代码稍微修改一下,既然打印数组的时候,“D”=>CHANGE没错,那我们修改第二个if语句的判断条件,代码如下:

  1. <?php 
  2. $array = array("A"=>1, "B"=>1, "C"=>1, "D"=>1); 
  3. foreach($array as $key => $value){ 
  4.     if($key == "B"){ 
  5.         $array["A"] = "CHANGE"; 
  6.         $array["D"] = "CHANGE"; 
  7.         print_r($array); 
  8.         echo '<br />'; 
  9.     } 
  10.      
  11.     if($array[$key] === "CHANGE") 
  12.         echo $value.'<br />'; 
  13. } 
  14. print_r($array); 
  15. ?> 

猜猜它会输出什么？$value肯定不会等于“CHANGE”啦！难道等于1么？代码如下:

Array ( [A] => CHANGE [B] => 1 [C] => 1 [D] => CHANGE )

那么,它确实就是1了。

这究竟是神马原因呢？翻到PHP文档的foreach那页，恍然：

Note: 除非数组是被引用,foreach 所操作的是指定数组的一个拷贝,而不是该数组本身,foreach对数组指针有些副作用,除非对其重置,在 foreach 循环中或循环后都不要依赖数组指针的值。

原来foreach所操作的是指定数组的一个拷贝,怪不得,取$value不管用了呢！理解到这里,上面的问题就解决了,只要在foreach中,直接按照键取$array中的元素进行各种判断赋值操作就可以了。

总结及延伸:PHP的数组遍历和操作能力确实非常强大,然而对一些稍复杂问题的解决方法却不是那么明显,其实在任何领域都是这样,一个语言和语法提供的都是基本的操作,对于复杂的问题的解决办法都需要开发者自己的思考、想象力和代码编写来完成。

------分隔线----------------------------

上一篇 php 几个常用的字符查找函数

下一篇 DedeCMS 自动定时更新首页html插件

------分隔线----------------------------

最新技术推荐

1Java并发编程的艺术(六)——线程间的通信 2Java并发编程的艺术(三)——volatile 3Node核心模块之Events 4myeclipse源码相关操作 5springMVC源码分析--RequestParamMethodArgumentResolver参数解析器（三） 6Java基本数据类型总结 7java结合testng，利用XML做数据源的数据驱动示例