前面我講過簡單的數組遍歷,這些基于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的數組遍歷和操作能力確實非常強大,然而對一些稍復雜問題的解決方法卻不是那么明顯,其實在任何領域都是這樣,一個語言和語法提供的都是基本的操作,對于復雜的問題的解決辦法都需要開發者自己的思考、想象力和代碼編寫來完成。