php数组操作函数(合并，拆分，追加，查找，删除等)

我们知道在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() 使用用户自定义的比较函数对数组中的值进行排序