我們知道在php中數組是我們開發中一個很重要的數據類型,下面我來給大家介紹PHP數組相關知識學習(合并,拆分,追加,查找,刪除,遍歷數組,數組排序等) ,有需要了解的同學可參考參考.

PHP數組相關知識學習,要學習的主要有以下幾點:

1、了解數組的感念；

2、掌握聲明一維數組和二維數組的方法；

3、掌握如何輸出數組；

4、掌握遍歷數組的方法；

5、了解如何合并數組；

6、掌握進行字符串與數組之間的轉換方法；

7、熟悉如何統計數組元素個數；

8、掌握丟數組排序的方法；

1. 合并數組

array_merge()函數將數組合并到一起,返回一個聯合的數組.所得到的數組以第一個輸入數組參數開始,按后面數組參數出現的順序依次迫加.其形式為:

array array_merge (array array1 array2…,arrayN)

這個函數將一個或多個數組的單元合并起來,一個數組中的值附加在前一個數組的后面.返回作為結果的數組.如果輸入的數組中有相同的字符串鍵名,則該鍵名后面的值將覆蓋前一個值.然而,如果數組包含數字鍵名,后面的值將不會覆蓋原來的值,而是附加到后面.如果只給了一個數組并且該數組是數字索引的,則鍵名會以連續方式重新索引.

實例代碼如下:

1. <?php 
2. $fruits = array("apple","banana","pear"); 
3. $numbered = array("1","2","3"); 
4. $cards = array_merge($fruits, $numbered); 
5. print_r($cards); 
6. // output 
7. // Array ( [0] => apple [1] => banana [2] => pear [3] => 1 [4] => 2 [5] => 3 ) 
8. ?>  

2. 追加數組

array_merge_recursive()函數與array_merge()相同,可以將兩個或多個數組合并在一起,形成一個聯合的數組．兩者之間的區別在于,當某個輸入數組中的某個鍵己經存在于結果數組中時該函數會采取不同的處理方式．array_merge()會覆蓋前面存在的鍵/值對,替換為當前輸入數組中的鍵/值對,而array_merge_recursive()將把兩個值合并在一起,形成一個新的數組,并以原有的鍵作為數組名.還有一個數組合并的形式,就是遞歸追加數組.其形式為:

array array_merge_recursive(array array1,array array2[…,array arrayN])

實例代碼如下:

1. <?php 
2. $fruit1 = array("apple" => "red", "banana" => "yellow"); 
3. $fruit2 = array("pear" => "yellow", "apple" => "green"); 
4. $result = array_merge_recursive($fruit1, $fruit2); 
5. print_r($result); 
6. // output 
7. // Array ( [apple] => Array ( [0] => red [1] => green ) [banana] => yellow [pear] => yellow ) 
8. ?>  

現在鍵 apple 指向一個數組,這個數組由兩個顏色值組成的索引數組.

3. 連接數組

array_combine()函數會得到一個新數組,它由一組提交的鍵和對應的值組成.其形式為:

array array_combine(array keys,array values)

注意,兩個輸入數組必須大小相同,不能為空.示例如下

實例代碼如下:

1. <?php 
2. $name = array("apple", "banana", "orange"); 
3. $color = array("red", "yellow", "orange"); 
4. $fruit = array_combine($name, $color); 
5. print_r($fruit); 
6. // output 
7. // Array ( [apple] => red [banana] => yellow [orange] => orange ) 
8. ?>  

4. 拆分數組 array_slice()

array_slice()函數將返回數組中的一部分,從鍵offset開始,到offset+length位置結束.其形式:

array array_slice (array array, int offset[,int length])

offset 為正值時,拆分將從距數組開頭的offset 位置開始；如果offset 為負值,則拆分從距數組末尾的offset 位置開始.如果省略了可選參數length,則拆分將從offset 開始,一直到數組的最后一個元素.如果給出了length 且為正數,則會在距數組開頭的offset+length 位置結束.相反,如果給出了length且為負數,則在距數組開頭的count(input_array)-|length|位置結束.考慮一個例子:

實例代碼如下:

1. <?php 
2. $fruits = array("Apple", "Banana", "Orange", "Pear", "Grape", "Lemon", "Watermelon"); 
3. $subset = array_slice($fruits, 3); 
4. print_r($subset); 
5. // output 
6. // Array ( [0] => Pear [1] => Grape [2] => Lemon [3] => Watermelon ) 
7. ?>  

然后我們使用下負長度:

實例代碼如下:

1. <?php 
2. $fruits = array("Apple", "Banana", "Orange", "Pear", "Grape", "Lemon", "Watermelon"); 
3. $subset = array_slice($fruits, 2, -2); 
4. print_r($subset); 
5. // output 
6. // Array ( [0] => Orange [1] => Pear [2] => Grape ) 
7. ?>  

5. 接合數組 array_splice()

array_splice()函數會刪除數組中從offset開始到offset+length 結束的所有元素,并以數組的形式返回所刪除的元素.其形式為:

array array_splice ( array array , int offset[,length[,array replacement]])

offset 為正值時,則接合將從距數組開頭的offset 位置開始,offset 為負值時,接合將從距數組末尾的offset 位置開始.如果忽略可選的length 參數,則從offset 位置開始到數組結束之間的所有元素都將被刪除.如果給出了length 且為正值,則接合將在距數組開頭的offset + leng th 位置結束.相反,如果給出了length且為負值,則結合將在距數組開頭的count(input_array)-length的位置結束.實例如下:

實例代碼如下:

1. <?php 
2. $fruits = array("Apple", "Banana", "Orange", "Pear", "Grape", "Lemon", "Watermelon"); 
3. $subset = array_splice($fruits, 4); 
4. print_r($fruits); 
5. print_r($subset); 
6. // output 
7. // Array ( [0] => Apple [1] => Banana [2] => Orange [3] => Pear ) 
8. // Array ( [0] => Grape [1] => Lemon [2] => Watermelon ) 
9. ?>  

可以使用可選參數replacement來指定取代目標部分的數組.實例如下:

實例代碼如下:

1. <?php 
2. $fruits = array("Apple", "Banana", "Orange", "Pear", "Grape", "Lemon", "Watermelon"); 
3. $subset = array_splice($fruits, 2, -1, array("Green Apple", "Red Apple")); 
4. print_r($fruits); 
5. print_r($subset); 
6. // output 
7. // Array ( [0] => Apple [1] => Banana [2] => Green Apple [3] => Red Apple [4] => Watermelon ) 
8. // Array ( [0] => Orange [1] => Pear [2] => Grape [3] => Lemon ) 
9. ?>  

從程序可以很清楚看到這個函數的使用方法了.

6. 數組的交集 array_intersect()

array_intersect()函數返回一個保留了鍵的數組,這個數組只由第一個數組中出現的且在其他每個輸入數組中都出現的值組成.其形式如下:

array array_intersect(array array1,array array2[,arrayN…])

下面這個例子將返回在$fruit1數組中出現的且在$fruit2和$fruit3中也出現的所有的水果:

實例代碼如下:

1. <?php 
2. $fruit1 = array("Apple","Banana","Orange"); 
3. $fruit2 = array("Pear","Apple","Grape"); 
4. $fruit3 = array("Watermelon","Orange","Apple"); 
5. $intersection = array_intersect($fruit1, $fruit2, $fruit3); 
6. print_r($intersection); 
7. // output 
8. // Array ( [0] => Apple ) 
9. ?>  

只有在兩個元素相等且具有相同的數據類型時,array_intersect()函數才會認為它們是相同的.

7. 關聯數組的交集 array_intersect_assoc()

函數array_intersect_assoc()與array_intersect()基本相同,只不過他在比較中還考慮了數組的鍵.因此,只有在第一個數組中出現,且在所有其他輸入數組中也出現的鍵/值對才返回到結果數組中.形式如下:

array array_intersect_assoc(array array1,array array2[,arrayN…])

下面的例子返回了出現在$fruit1數組中,也同時出現在$fruit2與$fruit3中的所有鍵/值對:

實例代碼如下:

1. <?php 
2. $fruit1 = array("red"=>"Apple","yellow"=>"Banana","orange"=>"Orange"); 
3. $fruit2 = array("yellow"=>"Pear","red"=>"Apple","purple"=>"Grape"); 
4. $fruit3 = array("green"=>"Watermelon","orange"=>"Orange","red"=>"Apple"); 
5. $intersection = array_intersect_assoc($fruit1, $fruit2, $fruit3); 
6. print_r($intersection); 
7. // output 
8. // Array ( [red] => Apple ) 
9. ?>  

8. 數組的差集 array_diff()

函數array_diff()返回出現在第一個數組中但其他輸入數組中沒有的值.這個功能與array_intersect()相反.

array array_diff(array array1,array array2[,arrayN…])

實例代碼如下:

1. <?php 
2. $fruit1 = array("Apple","Banana","Orange"); 
3. $fruit2 = array("Pear","Apple","Grape"); 
4. $fruit3 = array("Watermelon","Orange","Apple"); 
5. $intersection = array_diff($fruit1, $fruit2, $fruit3); 
6. print_r($intersection); 
7. // output 
8. // Array ( [1] => Banana ) 
9. ?>  

9. 關聯數組的差集 array_diff_assoc()

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

array array_diff_assoc(array array1,array array2[,arrayN…])

下面的例子只返回了[yellow] => Banana,因為這個特殊的鍵/值對出現在$fruit1中,而在$fruit2和$fruit3中都不存在.

實例代碼如下:

1. <?php 
2. $fruit1 = array("red"=>"Apple","yellow"=>"Banana","orange"=>"Orange"); 
3. $fruit2 = array("yellow"=>"Pear","red"=>"Apple","purple"=>"Grape"); 
4. $fruit3 = array("green"=>"Watermelon","orange"=>"Orange","red"=>"Apple"); 
5. $intersection = array_diff_assoc($fruit1, $fruit2, $fruit3); 
6. print_r($intersection); 
7. // output 
8. // Array ( [yellow] => Banana ) 
9. ?>  

使用數組的過程中經常要遍歷數組.通常需要遍歷數組并獲得各個鍵或值（或者同時獲得鍵和值）,所以毫不奇怪,PHP為此提供了一些函數來滿足需求.許多函數能完成兩項任務,不僅能獲取當前指針位置的鍵或值,還能將指針移向下一個適當的位置.

10. 獲取當前數組鍵 key()

key()函數返回input_array中當前指針所在位置的鍵.其形式如下:

mixed key(array array)

下面的例子通過迭代處理數組并移動指針來輸出$fruits數組的鍵:

實例代碼如下:

11. 獲取當前數組值 current()

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

mixed current(array array)

下面修改前面的例子,這一次我們要獲取數組值:

實例代碼如下:

1. $fruits = array("apple"=>"red", "banana"=>"yellow"); 
2. while ($fruit = current($fruits)) { 
3. printf("%s <br />", $fruit); 
4. next($fruits); 
5. } 
6. // red 
7. // yellow  

12. 獲取當前數組鍵和值 each()

each()函數返回input_array的當前鍵/值對,并將指針推進一個位置.其形式如下:

array each(array array)

返回的數組包含四個鍵,鍵0和key包含鍵名,而鍵1和value包含相應的數據.如果執行each()前指針位于數組末尾,則返回false.

實例代碼如下:

1. $fruits = array("apple", "banana", "orange", "pear"); 
2. print_r ( each($fruits) ); 
3. // Array ( [1] => apple [value] => apple [0] => 0 [key] => 0 ) 

each() 經常和 list() 結合使用來遍歷數組.本例與上例類似,不過循環輸出了整個數組:

實例代碼如下:

1. $fruits = array("apple", "banana", "orange", "pear"); 
2. reset($fruits); 
3. while (list($key, $val) = each($fruits)) 
4. { 
5. echo "$key => $val<br />"; 
6. } 
7. // 0 => apple 
8. // 1 => banana 
9. // 2 => orange 
10. // 3 => pear  

因為將一個數組賦值給另一個數組時會重置原來的數組指針,因此在上例中如果我們在循環內部將 $fruits 賦給了另一個變量的話將會導致無限循環.

這就完成了數組的遍歷.查找、篩選與搜索數組元素是數組操作的一些常見功能.下面來介紹一下幾個相關的函數.

13. in_array()函數

in_array()函數在一個數組匯總搜索一個特定值,如果找到這個值返回true,否則返回false.其形式如下:

boolean in_array(mixed needle,array haystack[,boolean strict]);

來看下面的例子,查找變量apple是否已經在數組中,如果在,則輸出一段信息:

實例代碼如下:

1. $fruit = "apple"; 
2. $fruits = array("apple","banana","orange","pear"); 
3. if( in_array($fruit,$fruits) )  
4. echo "$fruit 已經在數組中";  

第三個參數可選,它強制in_array()在搜索時考慮類型.

如果在一個數組中找到一個指定的鍵,函數array_key_exists()返回true,否則返回false.其形式如下:

boolean array_key_exists(mixed key,array array);

下面的例子將在數組鍵中搜索apple,如果找到,將輸出這個水果的顏色:

實例代碼如下:

1. $fruit["apple"] = "red"; 
2. $fruit["banana"] = "yellow"; 
3. $fruit["pear"] = "green"; 
4. if(array_key_exists("apple", $fruit)){ 
5. printf("apple's color is %s",$fruit["apple"]); 
6. } 
7. //apple's color is red  

15. array_search()函數

array_search()函數在一個數組中搜索一個指定的值,如果找到則返回相應的鍵,否則返回false.其形式如下:

mixed array_search(mixed needle,array haystack[,boolean strict])

下面的例子在$fruits中搜索一個特定的日期（December 7）,如果找到,則返回相應州的有關信息:

實例代碼如下:

1. $fruits["apple"] = "red"; 
2. $fruits["banana"] = "yellow"; 
3. $fruits["watermelon"]="green"; 
4. $founded = array_search("green", $fruits); 
5. if($founded) 
6. printf("%s was founded on %s.",$founded, $fruits[$founded]); 
7. //watermelon was founded on green. 

16. array_keys()函數

array_keys()函數返回一個數組,其中包含所搜索數組中找到的所有鍵.其形式如下:

array array_keys(array array[,mixed search_value])

如果包含可選參數search_value,則只會返回與該值匹配的鍵.下面的例子將輸出$fruit數組中找到的所有數組:

實例代碼如下:

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

array array_values(array array)

下面的例子將獲取$fruits中找到的各元素的值:

實例代碼如下:

1. $fruits["apple"] = "red"; 
2. $fruits["banana"] = "yellow"; 
3. $fruits["watermelon"]="green"; 
4. $values = array_values($fruits); 
5. print_r($values); 
6. //Array ( [0] => red [1] => yellow [2] => green )  

有時候我們需要擴展一個數組,或者刪掉數組的一部分,PHP為擴展和縮小數組提供了一些函數.對于那些希望模仿各種隊列實現（FIFO、LIFO）的程序員來說,這些函數可以提供便利.顧名思義,從這些函數的函數名（push、pop、shift和unshift）就清楚地反映出其作用.

PS:傳統的隊列是一種數據結構,刪除元素與加入元素的順序相同,就稱為先進先出,或FIFO.相反,棧是另外一種數據結構,其中刪除元素的順序與加入時的順序相反,這成為后進先出,或LIFO.

18. 在數組頭添加元素

array_unshift()函數在數組頭添加元素.所有己有的數值鍵都會相應地修改,以反映其在數組中的新位置,但是關聯鍵不受影響.其形式如下:

int array_unshift(array array,mixed variable[,mixed variable])

下面這個例子在$fruits數組前面添加了兩種水果:

實例代碼如下:

1. $fruits = array("apple","banana"); 
2. array_unshift($fruits,"orange","pear") 
3. // $fruits = array("orange","pear","apple","banana");  

19. 在數組尾添加元素

array_push()函數的返回值是int型,是壓入數據后數組中元素的個數,可以為此函數傳遞多個變量作為參數,同時向數組壓入多個變量.其形式為:

(array array,mixed variable [,mixed variable...])

下面這個例子在$fruits數組中又添加了兩個水果:

實例代碼如下:

array_shift()函數刪除并返回數組中找到的元素.其結果是,如果使用的是數值健,則所有相應的值都會下移,而使用關聯鍵的數組不受影響.其形式為

mixed array_shift(array array) 

下面的例子刪除了$fruits數組中的第一個元素apple:

實例代碼如下:

1. <pre lang="php"> 
2. $fruits = array("apple","banana","orange","pear"); 
3. $fruit = array_shift($fruits); 
4. // $fruits = array("banana","orange","pear") 
5. // $fruit = "apple";  

21. 從數組尾刪除元素

array_pop()函數刪除并返回數組的最后一個元素.其形式為:

mixed array_pop(aray target_array);

下面的例子從$states數組刪除了最后的一個州:

實例代碼如下:

1. $fruits = array("apple","banana","orange","pear"); 
2. $fruit = array_pop($fruits); 
3. //$fruits = array("apple","banana","orange"); 
4. //$fruit = "pear"; 

然后上面一些知識我們總結成一個函數

//聲明方法一、直接使用array()函數聲明數組,下標與數組元素見使用=&gt;連接,下標默認0開始

實例代碼如下:

1. <!--?php       $array=array("asp","php","jsp");       print_r($array);    ?--> 
2. //result: Array([0]=&gt;asp[1]=&gt;php[2]=&gt;jsp)    
3.  
4. //指定下標 
5. <!--?php      $array=array("1"=-->"asp","2"=&gt;"php","3"=&gt;"jsp"); 
6.   print_r($array); 
7.   echo" 
8. "; 
9.   echo $array[1]; 
10.   echo $array[2]; 
11.   echo $array[3]; 
12. ?&gt; 
13. /* 
14. result: 
15. Array([0]=&gt;asp[1]=&gt;php[2]=&gt;jsp) 
16. aspphpjsp 
17. */   
18.  
19. //聲明方法二、直接為數組賦值聲明數組 
20. <!--?php      $array[1]="asp";      $array[1]="php";      $array[1]="jsp";      print_r($array); //數組的輸出,可以使用echo,print對數組某個元素輸出,也可以使用print_r將數組與結構輸出    ?--> 
21. //result:Array([0]=&gt;asp[1]=&gt;php[2]=&gt;jsp)    
22.  
23. //數組的類型如下; 
24. <!--?php    //分類一、數字索引數組,索引從數字0開始,形成KEY-VALUE的鍵值對    Array([0]=-->asp[1]=&gt;php[2]=&gt;jsp) 
25. ?&gt;    
26.  
27. <!--?php    //分類二、關聯數組    $newarray=array("first"=-->1,"second"=&gt;2,"third"=&gt;3); 
28. echo $newarray["second"]; 
29. $newarray["third"]=8; 
30. echo $newarray["third"]; 
31. ?&gt; 
32. //result:28  
33. 一個數組的元素是變量時,這個數組就是一維數組； 
34. 一個數組的元素如果是一個一維數組,這個數組就是二維數組； 
35. 二維數組,exp: 
36. $str=array(    
37.   "書籍"=>array("文學","歷史","地理"),    
38.   "體育"=>array("m"=>"足球","n"=>"籃球")    
39. );  
40. print_r($str); 

數組函數大全

array() 創建數組.  

array_change_key_case() 返回其鍵均為大寫或小寫的數組.  

array_chunk() 把一個數組分割為新的數組塊.  

array_combine() 通過合并兩個數組來創建一個新數組.  

array_count_values() 用于統計數組中所有值出現的次數.  

array_diff() 返回兩個數組的差集數組.  

array_diff_assoc() 比較鍵名和鍵值,并返回兩個數組的差集數組.  

array_diff_key() 比較鍵名,并返回兩個數組的差集數組.  

array_diff_uassoc() 通過用戶提供的回調函數做索引檢查來計算數組的差集.  

array_diff_ukey() 用回調函數對鍵名比較計算數組的差集.  

array_fill() 用給定的值填充數組.  

array_filter() 用回調函數過濾數組中的元素.  

array_flip() 交換數組中的鍵和值.  

array_intersect() 計算數組的交集.  

array_intersect_assoc() 比較鍵名和鍵值,并返回兩個數組的交集數組.  

array_intersect_key() 使用鍵名比較計算數組的交集.  

array_intersect_uassoc() 帶索引檢查計算數組的交集,用回調函數比較索引.  

array_intersect_ukey() 用回調函數比較鍵名來計算數組的交集.  

array_key_exists() 檢查給定的鍵名或索引是否存在于數組中.  

array_keys() 返回數組中所有的鍵名.  

array_map() 將回調函數作用到給定數組的單元上.  

array_merge() 把一個或多個數組合并為一個數組.  

array_merge_recursive() 遞歸地合并一個或多個數組.  

array_multisort() 對多個數組或多維數組進行排序.  

array_pad() 用值將數組填補到指定長度.  

array_pop() 將數組最后一個單元彈出（出棧）.  

array_product() 計算數組中所有值的乘積.  

array_push() 將一個或多個單元（元素）壓入數組的末尾（入棧）.  

array_rand() 從數組中隨機選出一個或多個元素,并返回.  

array_reduce() 用回調函數迭代地將數組簡化為單一的值.  

array_reverse() 將原數組中的元素順序翻轉,創建新的數組并返回.  

array_search() 在數組中搜索給定的值,如果成功則返回相應的鍵名.  

array_shift() 刪除數組中的第一個元素,并返回被刪除元素的值.  

array_slice() 在數組中根據條件取出一段值,并返回.  

array_splice() 把數組中的一部分去掉并用其它值取代.  

array_sum() 計算數組中所有值的和.  

array_udiff() 用回調函數比較數據來計算數組的差集.  

array_udiff_assoc() 帶索引檢查計算數組的差集,用回調函數比較數據.  

array_udiff_uassoc() 帶索引檢查計算數組的差集,用回調函數比較數據和索引.  

array_uintersect() 計算數組的交集,用回調函數比較數據.  

array_uintersect_assoc() 帶索引檢查計算數組的交集,用回調函數比較數據.  

array_uintersect_uassoc() 帶索引檢查計算數組的交集,用回調函數比較數據和索引.  

array_unique() 刪除數組中重復的值.  

array_unshift() 在數組開頭插入一個或多個元素.  

array_values() 返回數組中所有的值.  

array_walk() 對數組中的每個成員應用用戶函數.  

array_walk_recursive() 對數組中的每個成員遞歸地應用用戶函數.  

arsort() 對數組進行逆向排序并保持索引關系.  

asort() 對數組進行排序并保持索引關系.  

compact() 建立一個數組,包括變量名和它們的值.  

count() 計算數組中的元素數目或對象中的屬性個數.  

current() 返回數組中的當前元素.  

each() 返回數組中當前的鍵／值對并將數組指針向前移動一步.  

end() 將數組的內部指針指向最后一個元素.  

extract() 從數組中將變量導入到當前的符號表.  

in_array() 檢查數組中是否存在指定的值.  

key() 從關聯數組中取得鍵名.  

krsort() 對數組按照鍵名逆向排序.  

ksort() 對數組按照鍵名排序.  

list() 把數組中的值賦給一些變量.  

natcasesort() 用“自然排序”算法對數組進行不區分大小寫字母的排序.  

natsort() 用“自然排序”算法對數組排序.  

next() 將數組中的內部指針向前移動一位.  

pos() current() 的別名.  

prev() 將數組的內部指針倒回一位.  

range() 建立一個包含指定范圍的元素的數組.  

reset() 將數組的內部指針指向第一個元素.  

rsort() 對數組逆向排序.  

shuffle() 把數組中的元素按隨機順序重新排列.  

sizeof() count() 的別名.  

sort() 對數組排序.  

uasort() 使用用戶自定義的比較函數對數組中的值進行排序并保持索引關聯.  

uksort() 使用用戶自定義的比較函數對數組中的鍵名進行排序.  

usort() 使用用戶自定義的比較函數對數組中的值進行排序