PHP有很多關于數(shù)組的函數(shù)，方便數(shù)組操作。

定義：

數(shù)組每個實體包含兩個項：key和value，可以通過查詢鍵來獲取其相應的值。這些鍵可以是數(shù)值(numerical)鍵或關聯(lián)(associative)鍵。數(shù)值鍵與值沒有真正的聯(lián)系，它們只是值在數(shù)組中的位置。

PHP提供了很多遍歷數(shù)組的方法，無法使用關聯(lián)鍵還是數(shù)值鍵，都依賴于一種稱為數(shù)組指針的特性。

創(chuàng)建數(shù)組

PHP不需要在創(chuàng)建數(shù)組時指定其大小，因為PHP是一種松散的語言，所以不需要在使用數(shù)組前先行聲明。盡管沒有限制，PHP仍提供了正式和非正式的數(shù)組聲明方法。

引用PHP數(shù)組的各個元素，用一對中括號來指示。數(shù)組沒有大小限制，所以只需建立引用就可以創(chuàng)建數(shù)組，例如：

$state[0]= ‘111';

$state[1]= ‘222';

如果索引值是數(shù)值索引而且是遞增的，還可以在創(chuàng)建時省略索引值。

$state[] =‘111';

$state[] =‘222';

可以使用array()創(chuàng)建數(shù)組,如：

$state =array(‘111', ‘222');

$state =array(‘one'=>'111', ‘two'=>'222');

使用list()提取數(shù)組,例如：

$state= array(‘one', ‘two', ‘three');

list($one,$two, $three) = $state;

數(shù)組內(nèi)的三個值分別賦給了$one, $two,$three, 可直接輸出。

用預定義的值范圍填充數(shù)組，例如：

$num= range(1, 6);

//類似于$num =array(1, 2, 3, 4, 5, 6);

可選擇奇偶：$num =range(1, 6, 2);

//$num= array(1, 3, 5);

可選擇字母：$ch =range(“A”, “F”);

//$ch= array(“A”, “B”, “C”, “D”, “E”, “F”);

輸出數(shù)組

輸出數(shù)組內(nèi)容最常用的方法就是迭代處理各個數(shù)組鍵，并輸出相應的值。

foreach()函數(shù)可以很方便的遍歷一個數(shù)組，得到每個value和key。

print_r()函數(shù)很方便將數(shù)組的內(nèi)容輸出到屏幕上。prinf_r()函數(shù)接受一個變量，并將其內(nèi)容發(fā)送給標準輸出，成功時返回TRUE，否則返回FALSE。

測試數(shù)組

通過is_array()函數(shù)知道某個特定變量是否一個數(shù)組。

is_array()函數(shù)確定某變量是否為數(shù)組，如果是則返回TRUE，否則返回FALSE。即使數(shù)組只包含一個值，也將被認為是一個數(shù)組。

添加和刪除數(shù)組元素

PHP為擴大和縮小數(shù)組提供了一些函數(shù)，對模仿各種隊列實現(xiàn)提供便利。

在數(shù)組頭添加元素：

array_unshift()函數(shù)在數(shù)組頭添加元素。所有已有的數(shù)值鍵都會相應地修改，以反映其在數(shù)組中的新位置，但是關聯(lián)鍵不受影響。

$state= array(‘11', ‘22', ‘33');

array_unshift($state,‘00');

//$state= array(‘00', ‘11', ‘22', ‘33');

在數(shù)組尾添加元素：

array_push()函數(shù)將值添加到數(shù)組的末尾，添加新的值之后返回數(shù)組中的元素總數(shù)。同時通過將這個變量作為輸入?yún)?shù)傳遞給此函數(shù)，向數(shù)組壓入多個變量(元素)，其形式為：

1. $state= array(‘1', ‘2'); 
2.  
3. array_push($state,‘3'); 
4.  
5. //$state= array(‘1', ‘2', ‘3'); 

從數(shù)組頭刪除元素：

array_shift()函數(shù)刪除并返回數(shù)組中找到的第一個元素。其結果是，如果使用的是數(shù)值鍵，則所有相應的值都會下移，而使用關聯(lián)鍵的數(shù)組不受影響，其形式為：

1. $state= array(‘1', ‘2'); 
2.  
3. array_shift($state); 
4.  
5. //$state= array(‘2'); 

從數(shù)組尾刪除元素：

array_pop()函數(shù)刪除并返回數(shù)組的最后一個元素，其形式為：

1. $state= array(‘1', ‘2'); 
2.  
3. array_pop($state); 
4.  
5. //$state= array(‘1'); 

定位數(shù)組元素

搜索數(shù)組：

in_array()函數(shù)在數(shù)組中搜索一個特定值，如果找到這個值則返回TRUE，否則返回FALSE，其形式如下：

1. $user= array(‘111', ‘222', ‘333'); 
2.  
3. $str= ‘111'; 
4.  
5. if(in_array($str,$user)){ 
6. //Vevb.com 
7. echo‘yes'; 
8.  
9. }else{ 
10.  
11. echo ‘no'; 
12.  
13. } 

第三個參數(shù)strict可選，它強制in_array()在搜索時考慮類型。

搜索關聯(lián)數(shù)組：

如果在一個數(shù)組中找到一個指定的鍵，函數(shù)array_key_exists()返回TRUE，否則返回FALSE。其形式如下：

1. $arr= array('one'=>'1', 'two'=>'2', 'three'=>'3'); 
2.   
3. if(array_key_exists('two',$arr)){ 
4.   
5. echo'yes'; 
6. //Vevb.com
7.   
8. }else{ 
9.   
10. echo‘no'; 
11.   
12. } 

搜索關聯(lián)數(shù)組：

array_search()函數(shù)在一個數(shù)組中搜索一個指定的值，如果找到則返回相應的值，否則返回FALSE，其形式如下：

1. $arr= array('one'=>'1', 'two'=>'2', 'three'=>'3'); 
2.  
3. if(array_search('1',$arr)){ 
4.  
5. echo'yes'; 
6.  
7. }else{ 
8.  
9. echo‘no'; 
10.  
11. } 

獲取數(shù)組鍵：

array_key()函數(shù)返回一個數(shù)組，其中包含所搜索數(shù)組中找到的所有鍵，其形式如下：

1. $arr= array('one'=>'1', 'two'=>'2', 'three'=>'3'); 
2.  
3. $keys= array_keys($arr); 
4.  
5. var_dump($keys); 
6.  
7. //array(3) {[0]=> string(3) "one" [1]=> string(3) "two" [2]=>string(5) "three" } 

獲取數(shù)組值：

array_values()函數(shù)返回一個數(shù)組中的所有值，并自動為返回的數(shù)組提供數(shù)組索引，其形式如下：

1. $arr= array('one'=>'1', 'two'=>'2', 'three'=>'3'); 
2.  
3. $values= array_values($arr); 
4.  
5. var_dump($values); 
6.  
7. //array(3) {[0]=> string(1) "1" [1]=> string(1) "2" [2]=>string(1) "3" } 

遍歷數(shù)組

通常需要遍歷數(shù)組并獲得各個鍵或值(或者同時獲得鍵和值)，PHP提供了一些函數(shù)來滿足需求。許多函數(shù)能完成兩項任務，不僅能獲取當前指針位置的鍵或值，還能將指針移向下一個適當?shù)奈恢谩?/p>

獲取當前數(shù)組鍵：

key()函數(shù)返回數(shù)組中當前指針所在位置的鍵，其形式如下：

1. $arr= array('one'=>'1', 'two'=>'2', 'three'=>'3'); 
2.  
3. $key= key($arr); 
4.  
5. var_dump($key); 
6.  
7. //string(3) "one" 

注意：每次調(diào)用key()時不會移動指針。

獲取當前數(shù)組值：

current()函數(shù)返回數(shù)組中當前指針所在位置的數(shù)組值。其形式如下：

1. $arr= array('one'=>'1', 'two'=>'2', 'three'=>'3'); 
2.  
3. $value= current($arr); 
4.  
5. var_dump($value); 
6.  
7. //string(1)“1” 

獲取當前數(shù)組鍵和值：

each()函數(shù)返回數(shù)組的當前鍵/值對，并將指針推進一個位置，其形式如下：

1. $arr =array('one'=>'1', 'two'=>'2', 'three'=>'3'); 
2.  
3. var_dump(each($arr)); 
4.  
5. //array(4) {[1]=> string(1) "1" ["value"]=> string(1)"1" [0]=> string(3) "one" ["key"]=>string(3) "one" } 

返回的數(shù)組包含4個鍵，鍵0和key鍵包含鍵名，而鍵1和value包含相應的數(shù)據(jù)。如果執(zhí)行each()前指針位于數(shù)組末尾，則返回FALSE。

移動數(shù)組指針：

1) 將指針移動到下一個數(shù)組位置

next()函數(shù)返回緊接著放在當前數(shù)組指針下一個位置的數(shù)組值，如果指針本來就位于數(shù)組的最后一個位置，則返回FALSE

1. $arr= array('one'=>'1', 'two'=>'2', 'three'=>'3'); 
2.  
3. echo next($arr); //輸出2 
4.  
5. echo next($arr); //輸出3 

2) 將指針移動到前一個數(shù)組位置

prev()函數(shù)返回位于當前指針前一個位置的數(shù)組值，如果指針本來就位于數(shù)組的第一個位置，則返回FALSE

3) 將指針移動到第一個數(shù)組位置

reset()函數(shù)用于將數(shù)組指針設置回數(shù)組的開始位置，如果需要在腳本中多次查看或處理一個數(shù)組，經(jīng)常使用這個函數(shù)，另外這個函數(shù)還經(jīng)常在排序結束時使用。

4) 將指針移動到最后一個數(shù)組位置

end()函數(shù)將指針移動到數(shù)組的最后一個位置，并返回最后一個元素。

向函數(shù)傳遞數(shù)組值：

array_walk()函數(shù)將數(shù)組中的各個元素傳遞到用戶自定義函數(shù)。如果需要對各個數(shù)組元素完成某個特定動作，這個函數(shù)將起作用。其形式如下：

1. functiontest($value ,$key){ 
2.  
3. echo$value.' '.$key." 
4.  
5. "; 
6. } 
7.  
8. $arr= array('one'=>'1', 'two'=>'2', 'three'=>'3'); 
9.  
10. array_walk($arr,'test'); 
11.  
12. //1 one 
13.  
14. //2 two 
15.  
16. //3 three 

如果使用多維數(shù)組，PHP5中引入的array_walk_recursive()函數(shù)可以遞歸地對數(shù)組中的每一個元素應用一個用戶定義函數(shù)。

確定數(shù)組大小和元素唯一性

確定數(shù)組的大小：

count()函數(shù)返回數(shù)組中值的總數(shù)

如果啟動了可選的mode參數(shù)(設置為1)，數(shù)組將進行遞歸計數(shù)統(tǒng)計元素。count(array(), 1);

注意：sizeof()函數(shù)是count()的別名。功能一致。

統(tǒng)計數(shù)組元素出現(xiàn)的頻率：

array_count_values()函數(shù)返回一個包含關聯(lián)鍵/值對的數(shù)組，其形式如下：

1. $arr= array('A', 'B', 'C', 'A'); 
2.  
3. $res= array_count_values($arr); 
4.  
5. print_r($res); 
6.  
7. //Array( [A] => 2 [B] => 1 [C] => 1 ) 

值表示出現(xiàn)的頻率。

確定唯一的數(shù)組元素：

array_unique()函數(shù)會刪除數(shù)組中所有重復的值，返回一個由唯一值組成的數(shù)組，其形式如下：

1. $arr= array('A', 'B', 'C', 'A'); 
2.  
3. $res= array_unique($arr); 
4.  
5. print_r($res); 
6.  
7. //Array( [0] => A [1] => B [2] => C ) 

可選參數(shù)sort_flags(PHP5.2.9中新增)可以確定如何對數(shù)組鍵排序。默認地，值會被作為字符串排序，不過也可以按數(shù)值對值排序(SORT_NUMERIC)，或使用PHP默認的排序方法(SORT_REGULAR)，還可以根據(jù)本地化環(huán)境排序(SORT_LOCALE_STRING)。

數(shù)組排序

逆置數(shù)組元素排序：

array_reverse()函數(shù)將數(shù)組中元素的順序逆置，其形式如下：

1. $arr= array('A', 'B', 'C'); 
2.  
3. $res= array_reverse($arr); 
4.  
5. print_r($res); 
6.  
7. //Array( [0] => C [1] => B [2] => A ) 

如果可選參數(shù)preserve_keys設置為TRUE，則保持鍵映射，否則重新擺放后的各個值將對應于先前該位置上的相應鍵。

1. $arr= array('A', 'B', 'C'); 
2.  
3. $res= array_reverse($arr, true); 
4.  
5. print_r($res); 
6.  
7. //Array( [2] => C [1] => B [0] => A ) 

置換數(shù)組鍵和值：

array_flip()函數(shù)將置換數(shù)組中鍵及其相應值的角色，其形式如下：

1. $arr= array('A', 'B', 'C'); 
2.  
3. $res= array_flip($arr); 
4.  
5. print_r($res); 
6.  
7. //Array( [A] => 0 [B] => 1 [C] => 2 ) 

數(shù)組排序：

sort()函數(shù)對數(shù)組進行排序，各元素按值由低到高的順序排列，其形式如下：

sort()函數(shù)不返回排序后的數(shù)組，相反它只是“就地”對數(shù)組排序，不論結果如何都不返回任何值。sort_flags參數(shù)可選，將根據(jù)這個參數(shù)指定的值修改該函數(shù)的默認行為。

1) SORT_NUMERIC，按數(shù)值排序。對整數(shù)和浮點數(shù)排序很有用。

2) SORT_REGULAR，按照相應的ASCII值對元素排序。

3) SORT_STRING，按接近于人所認知的正確順序?qū)υ嘏判颉?/p>

要保持初始鍵/值對應條件下的數(shù)組排序需要用到asort()函數(shù)。

assort()函數(shù)與sort()函數(shù)相同，以升序?qū)?shù)組排序，只不過它將保持鍵/值的關聯(lián)，其形式如下：

1. $arr= array('C', 'B', 'A'); 
2.  
3. $res= $arr; 
4.  
5. print_r($arr); 
6.  
7. sort($arr); 
8.  
9. print_r($arr); 
10.  
11. asort($res); 
12.  
13. print_r($res); 
14.  
15. //Array ( [0]=> C [1] => B [2] => A ) Array ( [0] => A [1] => B [2] => C )Array ( [2] => A [1] => B [0] => C ) 

以逆序?qū)?shù)組排序

rsort()函數(shù)與sort()函數(shù)相同，只不過它以相反的順序(降序)對數(shù)組元素排序。

如果使用可選的sort_flags參數(shù)，具體的排序行為將由這個值確定。

保持鍵/值對的條件下以逆序?qū)?shù)組排序

與asort()一樣，arsort()函數(shù)會保持鍵/值的關聯(lián)，但是它以逆序?qū)?shù)組up

1. $arr= array('C', 'B', 'A', 'D');  
2.  
3. arsort($arr);  
4.  
5. print_r($arr); 
6.   
7. //Array( [3] => D [0] => C [1] => B [2] => A ) 

如果使用可選的sort_flags參數(shù)，具體的排序行為將由這個值確定。

數(shù)組自然排序

natsort()函數(shù)提供了一種相當于人們平常使用的排序機制。

典型算法排序如下：

p1.jpg,p10.jpg, p2.jpg, p20.jpg

使用natsort()函數(shù)如下：

p1.jpg,p2.jpg, p10.jpg, p20.jpg

不區(qū)分大小寫的自然排序

如：

Picture1.jpg,PICTURE10.jpg, picture2.jpg, picture20.jpg

按鍵值對數(shù)組排序

ksort()函數(shù)按鍵對數(shù)組排序，如果成功則返回TRUE，失敗將返回FALSE

以逆序?qū)?shù)組鍵排序

krsort()函數(shù)的操作與ksort()相同，也按鍵排序，將以逆序排序。

根據(jù)用戶自定義規(guī)則排序

usort()函數(shù)提供了另一種排序方法，可以使用在該函數(shù)中指定的用戶自定義比較算法對數(shù)組排序。如果需要以某種方法對數(shù)據(jù)排序，而PHP的任何內(nèi)置排序函數(shù)沒有提供相應支持，就需要該函數(shù)。

數(shù)組合并、拆分、接合和分解

合并數(shù)組

array_merge()函數(shù)將數(shù)組合并到一起，返回一個聯(lián)合的數(shù)組。所得到的數(shù)組以第一個輸入數(shù)組參數(shù)開始，按后面數(shù)組參數(shù)出現(xiàn)的順序依次追加。其形式如下：

1. $arr= array('C', 'B', 'A', 'D'); 
2.  
3. $arr1= array('1', '2', '3', '4'); 
4.  
5. $arr2= array_merge($arr, $arr1); 
6.  
7. print_r($arr2); 
8.  
9. //Array( [0] => C [1] => B [2] => A [3] => D [4] => 1 [5] => 2 [6]=> 3 [7] => 4 ) 

遞歸追加數(shù)組

array_merge_recursive()函數(shù)與array_merge()相同，可以將兩個或多個數(shù)組合并到一起，形成一個聯(lián)合的數(shù)組。兩者之間的區(qū)別在于，當某個輸入數(shù)組中的某個鍵已經(jīng)存在于結果數(shù)組中時該函數(shù)會采取不同的處理方法。array_merge()會覆蓋前面存在的鍵/值對，將其替換為當前輸入數(shù)組中的鍵/值對，而array_merge_recursive()將兩個值合并在一起，形成一個新的數(shù)組并以原有的鍵作為數(shù)組名。其形式為：

1. $arr= array('one'=>'C', 'one'=>'B'); 
2.  
3. $arr1= array('three'=>'1', 'one'=>'2'); 
4.  
5. $arr2= array_merge_recursive($arr, $arr1); 
6.  
7. print_r($arr2); 
8.  
9. //Array( [one] => Array ( [0] => B [1] => 2 ) [three] => 1 ) 

合并兩個數(shù)組

array_combine()函數(shù)會生成一個新數(shù)組，這個數(shù)組由一組提交的鍵和對應的值組成，其形式為：

1. $arr= array('A', 'B'); 
2.  
3. $arr1= array('1', '2'); 
4.  
5. $arr2= array_combine($arr, $arr1); 
6.  
7. print_r($arr2); 
8.  
9. //Array( [A] => 1 [B] => 2 ) 

拆分數(shù)組

array_slice()函數(shù)將返回數(shù)組中的一部分，從鍵offset開始，到offset+length位置結束。

offset為正值時，拆分將從距數(shù)組開頭的offset位置開始;如果offset為負值，則拆分從距數(shù)組末尾的offset位置開始。如果省略了可選參數(shù)length，則拆分將從offset開始，一直到數(shù)組的最后一個元素。如果給出了length且為正數(shù)，則會在距數(shù)組開頭的offset+length位置結束。相反，如果給出了length且為負數(shù)，則在距數(shù)組開頭的count(array) - |length|位置結束。其形式如下：

1. $arr= array('A', 'B', 'C', 'D'); 
2.  
3. $arr1= array_slice($arr, 2, 1); 
4.  
5. print_r($arr1); 
6.  
7. //Array( [0] => C ) 

求數(shù)組的交集

array_intersect()函數(shù)返回一個保留了鍵的數(shù)組，這個數(shù)組只由第一個數(shù)組中出現(xiàn)的且在其他每個輸入數(shù)組中都出現(xiàn)的值組成。其形式如下：

1. $arr= array('A', 'B', 'C', 'D'); 
2.  
3. $arr1= array('A', 'B', 'E'); 
4.  
5. $arr2= array('A', 'F', 'D'); 
6.  
7. $arr3= array_intersect($arr, $arr1, $arr2); 
8.  
9. print_r($arr3); 
10.  
11. //Array( [0] => A ) 

注意：只有在兩個元素有相同的數(shù)據(jù)類型時，array_intersect()才會認為它們相等。

求關聯(lián)數(shù)組的交集

array_intersect_assoc()與array_intersect()基本相同，只不過它在比較中還考慮了數(shù)組的鍵。因此，只有在第一個數(shù)組中出現(xiàn)，且在所有其他輸入數(shù)組中也出現(xiàn)的鍵/值對才被返回到結果數(shù)組中。其形式如下：

1. $arr= array('a'=>'A', 'b'=>'B', 'c'=>'C', 'd'=>'D'); 
2.  
3. $arr1= array('a'=>'A', 'c'=>'B', 'E'); 
4.  
5. $arr2= array('a'=>'A', 'b'=>'F', 'd'=>'B'); 
6.  
7. $arr3= array_intersect_assoc($arr, $arr1, $arr2); 
8.  
9. print_r($arr3); 
10.  
11. //Array( [a] => A ) 

求關聯(lián)數(shù)組的差集

函數(shù)array_diff_assoc()與array_diff()基本相同，只是它在比較時還考慮了數(shù)組的鍵，因此，只在第一個數(shù)組中出現(xiàn)而不在其他輸入數(shù)組中出現(xiàn)的鍵/值對才會被返回到結果數(shù)組中。其形式如下：

1. $arr= array('a'=>'A', 'b'=>'B', 'c'=>'C', 'd'=>'D'); 
2.  
3. $arr1= array('a'=>'A', 'b'=>'B', 'e'=>'E'); 
4.  
5. $arr3= array_diff_assoc($arr, $arr1); 
6.  
7. print_r($arr3); 
8.  
9. //Array( [c] => C [d] => D ) 

其他有用的數(shù)組函數(shù)

返回一組隨機的鍵

array_rand()函數(shù)將返回數(shù)組中的一個或多個鍵。其形式為：

1. $arr= array('a'=>'A', 'b'=>'B', 'c'=>'C', 'd'=>'D'); 
2.  
3. $arr1= array_rand($arr, 2); 
4.  
5. print_r($arr1); 
6. //Vevb.com 
7. //Array( [0] => b [1] => d ) 

隨機洗牌數(shù)組元素

shuffle()函數(shù)隨機地對數(shù)組元素重新排序。

對數(shù)組中的值求和

array_sum()函數(shù)將數(shù)組內(nèi)的所有值加在一起，返回最終的和，其形式如下：

1. $arr= array('A', 32, 12, 'B'); 
2.  
3. $count= array_sum($arr); 
4.  
5. print_r($count); 
6.  
7. //44 

如果數(shù)組中包含其他數(shù)據(jù)類型(例如字符串)，這些值將被忽略。

劃分數(shù)組

array_chunk()函數(shù)將數(shù)組分解為一個多維數(shù)組，這個多維數(shù)組由多個包含size個元素的數(shù)組所組成。其形式如下：

1. $arr= array('A', 'B', 'C', 'D'); 
2.  
3. $arr1= array_chunk($arr, 2); 
4.  
5. print_r($arr1); 
6.  
7. //Array( [0] => Array ( [0] => A [1] => B ) [1] => Array ( [0] => C [1]=> D ) )