PHP数组操作

gyts62

　　对于Web编程来说，最重要的就是存取和读写数据了。存储方式可能有很多种，可以是字符串、数组、文件的形式等。数组，可以说是PHP的数据应用中较重要的一种方式。PHP的数组函数众多，下面是我学习的小结，借此记之，便于以后鉴之。
　　------------------------------基础-------------------------------

1. 数组定义
　　数组的定义使用 array()方式定义，可以定义空数组：





<?php
$number = array(1,3,5,7,9);
//定义空数组
$result = array();
$color =array("red","blue","green");
//自定义键值
$language = array(1=>"English",3=>"Chinese",5=>"Franch");
//定义二维数组
$two = array(
"color"=>array("red","blue"),    //用逗号结尾
"week"=>array("Monday","Friday")    //最后一句没有标点
         )；
?>
　　

2. 创建数组
　　compact()
　　compact()函数——将一个或多个变量（包含数组）转换为数组：array compact ( mixed $varname [, mixed $... ] )。





        <?PHP
$number = "1,3,5,7,9";
$string = "I'm PHPer";
$array = array("And","You?");
$newArray = compact("number","string","array");
print_r ($newArray);
?>
　　
　　compact()函数用于将两个或多个变量转换为数组，当然也包含数组变量。其参数是变量的名称而非带有$全名。相反的函数是extract()作用顾名思义就是将数组转换为单个的字符串，键值作为其字符串名称，数组值作为字符串的值。
　　运行结果:





Array (
[number] => 1,3,5,7,9
[string] => I'm PHPer
[array] => Array ( [0] => And [1] => You? )
)
　　
　　array_combine()
　　array_combine()——将两个数组重组成一个数组,一个作键值一个做的值：array array_combine ( array $keys , array $values )





        <?PHP
$number = array("1","3","5","7","9");
$array = array("I","Am","A","PHP","er");
$newArray = array_combine($number,$array);
print_r ($newArray);
?>
　　
　　array_combine函数不多说了，谁看了都明白。
　　运行结果：





Array ( [1] => I [3] => Am [5] => A [7] => PHP [9] => er )
　　
　　range()
　　range()函数——创建指定范围的数组：





<?PHP
$array1 = range(0,100,10);//0为起始值，100为结束值，10为步进值(默认步进值为1).
print_r($array1);
echo"<br />";
$array2 = range("A","Z");
print_r($array2);
echo "<br />";
$array3 = range("z","a");
print_r($array3);
?>
　　
　　array_fill()
　　array_fill()函数——填充数组函数：


　　运行结果：





    <?PHP
02             $array = range(1,10);
03             $fillarray = range("a","d");
04             $arrayFilled = array_fill(0,5,$fillarray);//这里的$fillarray可以是字符串，如"test".
05             echo "<pre>";
06             print_r ($arrayFilled);
07             echo "</pre>";
08             $keys = array("string","2",9,"SDK","PK");
09             $array2 = array_fill_keys($keys,"testing");
10             echo "<pre>";
11             print_r ($array2);
12             echo "</pre>";
13     ?>
运行结果：
01     Array
02     (
03         [0] => Array
04             (
05                 [0] => a
06                 [1] => b
07                 [2] => c
08                 [3] => d
09             )
10      
11         [1] => Array
12             (
13                 [0] => a
14                 [1] => b
15                 [2] => c
16                 [3] => d
17             )
18      
19         [2] => Array
20             (
21                 [0] => a
22                 [1] => b
23                 [2] => c
24                 [3] => d
25             )
26      
27         [3] => Array
28             (
29                 [0] => a
30                 [1] => b
31                 [2] => c
32                 [3] => d
33             )
34      
35         [4] => Array
36             (
37                 [0] => a
38                 [1] => b
39                 [2] => c
40                 [3] => d
41             )
42      
43     )
44     Array
45     (
46         [string] => testing
47         [2] => testing
48         [9] => testing
49         [SDK] => testing
50         [PK] => testing
51     )
　　

3. 数组的遍历
　　foreach遍历
　　foreach (array_expression as $value){}
　　foreach (array_expression as $key => $value){}


　　运行结果：





    <?PHP
2         $speed = array(50,120,180,240,380);
3         foreach($speed as $keys=>$values){
4             echo $keys."=>".$values."<br />";
5         }
6     ?>
运行结果：
1     0=>50
2     1=>120
3     2=>180
4     3=>240
5     4=>380
　　
　　while循环遍历
　　while循环遍历一般结合list函数，以下是实例





//each():
　　each() 函数生成一个由数组当前内部指针所指向的元素的键名和键值组成的数组，并把内部指针向前移动。
　　返回的数组中包括的四个元素：键名为 0，1，key 和 value。单元 0 和 key 包含有数组单元的键名，1 和 value 包含有数据。

<?php $people = array("Peter", "Joe", "Glenn", "Cleveland"); print_r (each($people)); ?>
输出：
Array ( [1] => Peter [value] => Peter [0] => 0 [key] => 0 )

//list
<?php $my_array = array("Dog","Cat","Horse");
list($a, $b, $c) = $my_array;
echo "I have several animals, a $a, a $b and a $c.";
?>  
<?PHP
02         $staff = array(
03             array("姓名","性别","年龄"),
04             array("小张","男",24),
05             array("小王","女",25),
06             array("小李","男",23)
07         );
08         echo "<table border=2>";
09         while(list($keys,$value) = each($staff)){
10             list($name,$sex,$age) = $value;
11             echo "<tr><td>$name</td><td>$sex</td><td>$age</td></tr>";
12         }
13         echo "</table>";
14        ?>
　　
　　for循环遍历





    <?PHP
2         $speed = range(0,220,20);
3         for($i =0;$i<count($speed);$i++) {
4             echo $speed[$i]." ";
5         }
6     ?>
运行结果：
1     0 20 40 60 80 100 120 140 160 180 200 220
　　



4. 数组的指针操作
　　涉及函数包括reset、prev、end、next、current、each。
　　实例一：next 与 prev


　　





    <?PHP
02         $speed = range(0,220,20);
03         echo current($speed);//输出当前位置的值（在数组的开头位置）
04         $i = rand(1,11);
05         while($i--){
06             next($speed);//指针从当前位置向后移动一位
07         }
08         echo current($speed);//输出当前位置的值
09         echo "<br />";
10         echo prev($speed);//输出前一位置数组值
11         echo "<br />";
12         echo reset($speed);//重置数组的指针，将指针指向起始位置
13         echo "<br />";
14         echo end($speed);//输出最后位置的数组值
15         echo "<br />";
16     ?>
运行结果：
1     0220
2     200
3     0
4     220
　　
　　实例二：each函数指针操作





    <?PHP
02         $speed = range(0,200,40);
03         echo "each实现指针下移 <br />";
04         echo "0挡的速度是".current(each($speed))."<br />";
05         echo "1挡的速度是".current(each($speed))."<br />";
06         echo "2挡的速度是".current(each($speed))."<br />";
07         echo "3挡的速度是".current(each($speed))."<br />";
08         echo "4挡的速度是".current(each($speed))."<br />";
09         echo "5挡的速度是".current(each($speed))."<br />";
10         echo "使用each函数实现数组指针的移动，进行数组遍历 <br />";
11         reset($speed);//这里是将数组指针指向数组首
12         while(list($key,$value)=each($speed)){
13             echo $key."=>".$value."<br />";
14         }
15     ?>
运行结果：
01     each实现指针下移
02     0挡的速度是0
03     1挡的速度是40
04     2挡的速度是80
05     3挡的速度是120
06     4挡的速度是160
07     5挡的速度是200
08     使用each函数实现数组指针的移动，进行数组遍历
09     0=>0
10     1=>40
11     2=>80
12     3=>120
13     4=>160
14     5=>200
　　



5. 数组的增添删改操作
　　增添数组成员
　　实例一：$num[] = value直接赋值追加到数组末尾：





    <?PHP
2         $num = array(1=>80,2=>120,3=>160);
3         echo "使用表达式添加数组成员<br />";
4         $num[]=240;
5         print_r($num);
6       ?>
运行结果：
1     使用表达式添加数组成员
2     Array ( [1] => 80 [2] => 120 [3] => 160 [4] => 240 )
　　


　　实例二：array_pad函数，数组数组首尾选择性追加





   array_pad(array,size,value):返回数组会重新索引
size:必需。指定的长度。整数则填补到右侧，负数则填补到左侧。
  注释：如果 size 参数小于原始数组的长度，该函数不会删除任何元素。



<?PHP
2         $num = array(1=>80,2=>120,3=>160);
3         $num = array_pad($num,4,200);
4         echo "使用array_pad函数向数组尾部添加成员<br />";
5         print_r($num);
6         echo "<br />array_pad 还可以填充数组首部<br />";
7         $num = array_pad($num,-8,40);
8         print_r($num);
9     ?>
运行结果：
1     使用array_pad函数向数组尾部添加成员
2     Array ( [0] => 80 [1] => 120 [2] => 160 [3] => 200 )
3     array_pad 还可以填充数组首部
4     Array ( [0] => 40 [1] => 40 [2] => 40 [3] => 40 [4] => 80 [5] => 120 [6] => 160 [7] => 200 )
　　


　　实例三：入栈操作追加（array_push）：





    <?PHP
2         $num = array(1=>80,2=>120,3=>160);
3         array_push($num,200,240,280);//可以自己追加，直接加在数组结尾
4         print_r($num);
5     ?>
运行结果：
1     Array ( [1] => 80 [2] => 120 [3] => 160 [4] => 200 [5] => 240 [6] => 280 )
　　
　　


　　实例四：array_unshift()在开头添加数组成员





1     <?PHP
2         $num = array(1=>80,2=>120,3=>160);
3         array_unshift($num,0,40);//可以自己追加，直接加在数组结尾
4         print_r($num);
5     ?>
运行结果：
1     Array ( [0] => 0 [1] => 40 [2] => 80 [3] => 120 [4] => 160 )
　　


　　注意：array_unshift()函数使用后数组的键值将会从0开始！
　　删减数组成员
　　实例一：unset()命令删除数组成员或数组：





    <?PHP
02         $num = array_fill(0,5,rand(1,10));
03         print_r($num);
04         echo "<br />";
05         unset($num[4]);
06         print_r($num);
07         echo "<br />";
08         unset($num);
09         if(is_array){
10             echo "unset命令不能删除整个数组";
11         }else{
12             echo "unset命令可以删除数组";
13         }
14     ?>
运行结果：（运行出错及说明数组也被删除，不再存在）
1     Array ( [0] => 9 [1] => 9 [2] => 9 [3] => 9 [4] => 9 )
2     Array ( [0] => 9 [1] => 9 [2] => 9 [3] => 9 )
3      
4     Notice: Use of undefined constant is_array - assumed 'is_array' in H:\wamp\www\testing\editorplus\test.php on line 21
　　


　　实例二：array_splice()函数删除数组成员
　　array_splice(array,offset,length,array)
　　array：被移除的元素由此数组中的元素替代。如果没有移除任何值，则此数组中的元素将插入到指定位置。





    <?php
2             $a=array("red", "green", "blue", "yellow");  
3             count ($a); //得到4  
4             array_splice($a,1,1); //删除第二个元素  
5             count ($a); //得到3  
6             echo $a[2]; //得到yellow  
7             echo $a[1]; //得到blue  
8     ?>
　　
　　实例三：array_unique删除数组中的重复值：





    <?php
2         $a=array("red", "green", "blue", "yellow","blue","green");  
3         $result = array_unique($a);
4         print_r($result);
5     ?>
运行结果：
1     Array ( [0] => red [1] => green [2] => blue [3] => yellow )
　　


　　实例四：array_merge、array_merge_recursive合并数组


　　





    <?php
02         $array1 = array("r"=>"red",1,2,3,4);
03         $array2 = array("b"=>"blue",4=>5,6,7,8,9);
04         $array3 = array("r"=>"read",4=>10,2=>11);
05         $array4 = array(
06             array(4=>10),
07             array(7=>13)
08         );
09         $array5 = array(
10             array(4=>11),
11             array(6=>12)
12         );
13         $result = array_merge($array1,$array2,$array3,$array4,$array5);
14         echo "<pre>";
15         print_r($result);
16         echo "</pre>";
17         $result = array_merge_recursive($array1,$array2,$array3,$array4,$array5);
18         echo "<pre>";
19         print_r ($result);
20         echo "</pre>";
21     ?>
运行结果：
01     Array
02     (
03         [r] => read
04         [0] => 1
05         [1] => 2
06         [2] => 3
07         [3] => 4
08          => blue
09         [4] => 5
10         [5] => 6
11         [6] => 7
12         [7] => 8
13         [8] => 9
14         [9] => 10
15         [10] => 11
16         [11] => Array
17             (
18                 [4] => 10
19             )
20      
21         [12] => Array
22             (
23                 [7] => 13
24             )
25      
26         [13] => Array
27             (
28                 [4] => 11
29             )
30      
31         [14] => Array
32             (
33                 [6] => 12
34             )
35      
36     )
37     Array
38     (
39         [r] => Array
40             (
41                 [0] => red
42                 [1] => read
43             )
44      
45         [0] => 1
46         [1] => 2
47         [2] => 3
48         [3] => 4
49          => blue
50         [4] => 5
51         [5] => 6
52         [6] => 7
53         [7] => 8
54         [8] => 9
55         [9] => 10
56         [10] => 11
57         [11] => Array
58             (
59                 [4] => 10
60             )
61      
62         [12] => Array
63             (
64                 [7] => 13
65             )
66      
67         [13] => Array
68             (
69                 [4] => 11
70             )
71      
72         [14] => Array
73             (
74                 [6] => 12
75             )
76      
77     )
　　
　　注：1. array_merge的键名是数字的将重新建立索引；遇到相同的字符串键名时，后面的将覆盖前面的。 2. array_merge_recursive函数的作用是将相同字符串的键名单元整合成一个数组。

6. 数组的键值和值操作
　　实例一：in_array()检测数组中是否有某个值存在





    <?php
2         $array = range(0,9);
3         if(in_array(9,$array)){
4             echo "数组中存在";
5         }
6     ?>
　　
　　运行结果：数组中存在
　　实例二：key()取得数组当前的键名：





    <?php
2         $array = range(0,9);
3         $num = rand(0,8);
4         while($num--)
5         next($array);
6         $key = key($array);
7         echo $key;
8     ?>
　　
　　此实例结果为动态结果，范围（0-8），不做结果演示。
　　实例三：list()函数把数组中的值赋给指定变量：





    <?PHP
02             $staff = array(
03                 array("姓名","性别","年龄"),
04                 array("小张","男",24),
05                 array("小王","女",25),
06                 array("小李","男",23)
07             );
08             echo "<table border=2>";
09             while(list($keys,$value) = each($staff)){
10                 list($name,$sex,$age) = $value;
11                 echo "<tr><td>$name</td><td>$sex</td><td>$age</td></tr>";
12             }
13             echo "</table>";
14     ?>
　　
　　实例四：array_flip()交换数组的键值和值:





    <?PHP
2         $array = array("red","blue","yellow","Black");
3         print_r($array);
4         echo "<br />";
5         $array = array_flip($array);
6         print_r($array);
7        ?>
运行结果：
1     Array ( [0] => red [1] => blue [2] => yellow [3] => Black )
2     Array ( [red] => 0 [blue] => 1 [yellow] => 2 [Black] => 3 )
　　


　　实例五：array_keys()、array_values()返回数组中所有的键值和值：





    <?PHP
2         $array = array("red","blue","yellow","Black");
3         $result = array_keys($array);
4         print_r($result);
5         echo "<br />";
6         $result = array_values($array);
7         print_r($result);
8        ?>
运行结果：
1     Array ( [0] => 0 [1] => 1 [2] => 2 [3] => 3 )
2     Array ( [0] => red [1] => blue [2] => yellow [3] => Black )
　　


　　实例六：array_search()搜索数值:





1     <?PHP
2         $array = array("red","blue","yellow","Black");
3         $result = array_search("red",$array);
4         if(($result === NULL)){
5             echo "不存在数值red";
6         }else{
7             echo "存在数值 $result";
8         }
9        ?>
　　
　　结果：存在数值 0
　　函数array_search()返回的值可能为false或0或NULL，所以在判断时注意要用"==="

7. 数组的排序
　　实例一：sort()、rsort()/asort()、arsort()对数组排序：





    <?PHP
2         $array = array("b","c","d","a");
3         sort($array);//从低到高排序
4         print_r($array);
5         echo "<br />";
6         rsort($array);//逆向排序
7         print_r($array);
8     ?>
结果：
1     Array ( [0] => a [1] => b [2] => c [3] => d )
2     Array ( [0] => d [1] => c [2] => b [3] => a )
　　


　　sort()、rsort()函数对数组进行从低到高的排序，返回结果为bool值；
　　asort()、arsort()函数是保留键值的排序，排序后键值不重新索引。
　　实例二：将数组顺序打乱——shuffle()函数：





    <?PHP
2         $array = array("a","b","c","d");
3         shuffle($array);//从低到高排序
4         print_r($array);
5     ?>
结果为动态结果：
1     Array ( [0] => c [1] => a [2] => d [3] => b )
　　


　　shuffle的结果有点随机的意味，每次刷新都不一样。
　　实例三：array_reverse()数组反向：





    <?PHP
2         $array = array("d","b","a","c");
3         $array = array_reverse($array);//从低到高排序
4         print_r($array);
5     ?>
运行结果：
1     Array ( [0] => c [1] => a [2] => b [3] => d )
　　


　　实例四：自然排序算法——natsort()和natcasesort();





    <?PHP
2         $array = array("sort2","Sort5","sort1","sort4");
3         natsort($array);//从低到高排序
4         print_r($array);
5         echo "<br />";
6         natcasesort($array);
7         print_r($array);
8     ?>
结果：
1     Array ( [1] => Sort5 [2] => sort1 [0] => sort2 [3] => sort4 )
2     Array ( [2] => sort1 [0] => sort2 [3] => sort4 [1] => Sort5 )
　　


　　natsort()、natcasesort()对数组进行自然排序，就是使用数字的正常排序算法。natcasesort会忽略大小写。
　　实例五：对数组进行键值排序ksort():





    <?PHP
2         $array = array(1=>"sort2",4=>"Sort5",2=>"sort1",3=>"sort4");
3         ksort($array);//从低到高排序
4         print_r($array);
5     ?>
结果：
1     Array ( [1] => sort2 [2] => sort1 [3] => sort4 [4] => Sort5 )
　　


　　注意：ksort()函数重新建立了索引。

8. 数组的其他用法





01     cout($array) --------统计数组的单元个数
02     array_diff($array1,$array2)----------统计数组之间的不同点，返回第一个数组中有而第二个数组中没有的。
03     array_diff_assoc($array1,$array2)---------同array_diff()，只是它对键值也比较
04     array_diff_key($array1,$array2)------------比较键值
05     array_product($array)-----------返回数组的所有数的乘积
06     array_sum($array)--------------所有数值的和
07     array_rand($array,$n)----------在$array数组中取出$n个数值，返回数组
08     array_intersect($array1,$array2)----------------取得两个数组的交集
09     array_intersect_assoc($array1,$array2)---------------在array_intersect 的基础上进行键值比较
10     array_intersect_key($array1,$array2)-----------------比较两个数组键值的交集
　　

总结
　　数组的使用在PHP中至关重要，由于PHP没有指针，所以数组承担了很大的数据操作任务。学好数组，才能把PHP应用的得心应手，这里所列均是常用的PHP数组相关的函数及用法，欢迎一起学习！
　　
　　
　　------------------------------常用函数-------------------------------
　　数组运用的熟练有时候能解决很多问题。熟悉相关函数就能事半功倍。看看下面有关数组的函数你是否都熟悉呢？

一、数组操作的基本函数
　　数组的键名和值

• array_values($arr);获得数组的值
  
• array_keys($arr);获得数组的键名
  
• array_flip($arr);数组中的值与键名互换（如果有重复前面的会被后面的覆盖）
  
• in_array("apple",$arr);在数组中检索apple
  
• array_search("apple",$arr);在数组中检索apple ，如果存在返回键名
  
• array_key_exists("apple",$arr);检索给定的键名是否存在数组中
  
• isset($arr[apple]):检索给定的键名是否存在数组中
  

　　数组的内部指针

• current($arr);返回数组中的当前单元
  
• pos($arr);返回数组中的当前单元
  
• key($arr);返回数组中当前单元的键名
  
• prev($arr);将数组中的内部指针倒回一位
  
• next($arr);将数组中的内部指针向前移动一位
  
• end($arr);将数组中的内部指针指向最后一个单元
  
• reset($arr;将数组中的内部指针指向第一个单元
  
• each($arr);将返回数组当前元素的一个键名/值的构造数组，并使数组指针向前移动一位
  
• list($key,$value)=each($arr);获得数组当前元素的键名和值
  

　　数组和变量之间的转换
　　extract($arr);用于把数组中的元素转换成变量导入到当前文件中，键名当作变量名，值作为变量值注：（第二个参数很重要，可以看手册使用）使用方法 echo $a; compact(var1,var2,var3);用给定的变量名创建一个数组

二、数组的分段和填充
　　数组的分段

• array_slice($arr,0,3);可以将数组中的一段取出，此函数忽略键名
  
• array_splice($arr,0,3，array("black","maroon"));可以将数组中的一段取出，与上个函数不同在于返回的序列从原数组中删除
  

　　分割多个数组

• array_chunk($arr,3,TRUE);可以将一个数组分割成多个，TRUE为保留原数组的键名
  

　　数组的填充

• array_pad($arr,5,'x');将一个数组填补到制定长度
  

三、数组与栈

• array_push($arr,"apple","pear");将一个或多个元素压入数组栈的末尾（入栈），返回入栈元素的个数
  
• array_pop($arr);将数组栈的最后一个元素弹出（出栈）
  

四、数组与队列

• array_shift($arr);数组中的第一个元素移出并作为结果返回（数组长度减1，其他元素向前移动一位，数字键名改为从零技术，文字键名不变）
  
• array_unshift($arr,"a",array(1,2));在数组的开头插入一个或多个元素
  

五、回调函数

• array_walk($arr,'function','words');使用用户函数对数组中的每个成员进行处理（第三个参数传递给回调函数function）
  
• array_mpa("function",$arr1,$arr2);可以处理多个数组（当使用两个或更多数组时，他们的长度应该相同）
  
• array_filter($arr,"function");使用回调函数过滤数组中的每个元素，如果回调函数为TRUE，数组的当前元素会被包含在返回的结果数组中，数组的键名保留不变
  
• array_reduce($arr,"function","*");转化为单值函数（*为数组的第一个值）
  

六、数组的排序
　　通过元素值对数组排序

• sort($arr);由小到大的顺序排序（第二个参数为按什么方式排序）忽略键名的数组排序
  
• rsort($arr);由大到小的顺序排序（第二个参数为按什么方式排序）忽略键名的数组排序
  
• usort($arr,"function");使用用户自定义的比较函数对数组中的值进行排序（function中有两个参数，0表示相等，正数表示第一个大于第二个，负数表示第一个小于第二个）忽略键名的数组排序
  
• asort($arr);由小到大的顺序排序（第二个参数为按什么方式排序）保留键名的数组排序
  
• arsort($arr);由大到小的顺序排序（第二个参数为按什么方式排序）保留键名的数组排序
  
• uasort($arr,"function");使用用户自定义的比较函数对数组中的值进行排序（function中有两个参数，0表示相等，正数表示第一个大于第二个，负数表示第一个小于第二个）保留键名的数组排序
  

　　通过键名对数组排序

• ksort($arr);按照键名正序排序
  
• krsort($arr);按照键名逆序排序
  
• uksort($arr,"function");使用用户自定义的比较函数对数组中的键名进行排序（function中有两个参数，0表示相等，正数表示第一个大于第二个，负数表示第一个小于第二个）
  

　　自然排序法排序

• natsort($arr);自然排序（忽略键名）
  
• natcasesort($arr);自然排序（忽略大小写，忽略键名）
  

七、数组的计算
　　数组元素的求和

• array_sum($arr);对数组内部的所有元素做求和运算
  

　　数组的合并

• array_merge($arr1,$arr2);合并两个或多个数组（相同的字符串键名，后面的覆盖前面的，相同的数字键名，后面的不会做覆盖操作，而是附加到后面） “+”$arr1+$arr2;对于相同的键名只保留后一个
  
• array_merge_recursive($arr1,$arr2);递归合并操作，如果数组中有相同的字符串键名，这些值将被合并到一个 数组中去。如果一个值本身是一个数组，将按照相应的键名把它合并为另一个数组。当数组具有相同的数组键名时，后一个值将不会覆盖原来的值，而是附加到后面
  

　　数组的差集

• array_diff($arr1,$arr2);返回差集结果数组
  
• array_diff_assoc($arr1,$arr2,$arr3);返回差集结果数组，键名也做比较
  

　　数组的交集

• array_intersect($arr1,$arr2);返回交集结果数组
  
• array_intersect_assoc($arr1,$arr2);返回交集结果数组，键名也做比较
  

八、其他的数组函数
　　数组元素的求和

• range(0,12);创建一个包含指定范围单元的数组
  
• array_unique($arr);移除数组中重复的值，新的数组中会保留原始的键名
  
• array_reverse($arr,TRUE);返回一个单元顺序与原数组相反的数组，如果第二个参数为TRUE保留原来的键名
  
• srand((float)microtime()*10000000); 随机种子触发器
  
• array_rand($arr,2);从数组中随机取出一个或多个元素
  
• shuffle($arr);将数组的顺序打乱
  

　　

　　

　　

　　在PHP应用中，数组是用得最广泛的数据结构了。基本可以这么说，熟练掌握数组你就可以熟练掌握PHP的大部分了。下面将PHP的数组操作进行汇总介绍下，或许有你不懂或不怎么了解的数组操作。
　　将数组的内部指针倒回一位：





    /**
02     * 将数组的内部指针倒回一位
03     * @param array &$arr
04     * @return mixed 返回前一个单元的值，当没有更多单元时返回 FALSE
05     *                         如果数组包含空的单元，或者单元的值是 0 则本函数碰到这些单元也返回 FALSE
06     *                         要正确遍历可能含有空单元或者单元值为 0 的数组，参见 each() 函数
07     */
08     mixed prev(array &$arr);
09      
10     <?php
11     $transport = array('foot', 'bike', 'car', 'plane');
12     $mode = current($transport); // $mode = 'foot';
13     $mode = next($transport);    // $mode = 'bike';
14     $mode = next($transport);    // $mode = 'car';
15     $mode = prev($transport);    // $mode = 'bike';
16     $mode = end($transport);     // $mode = 'plane';
17     $mode = reset($transport) ;//$mode = 'foot';
18      
19     ?>
　　
　　把数组中的单元转换为变量：





    array("key"=>"value");建立数组
2     //显示数组
3     print_r($array);
4     //使用compact()函数新建数组,并把参数做为新数组的单元;
5     $newArray = compact("red","green","yellow","blue","array");
6     //使用extract()函数把数组中的单元转换为变量
7     extract($exArray);
8     echo "$key1 $key2 $key3 $key4 $key5";
　　
　　检查值、键：





1     array_key_exists($key,$array);//检查数组键
2     in_array($value,$array);//检查值于数组
　　
　　获取值：





//使用array_values()取得数组的值
2     $carValues = array_values($car);
3     //取出数组的键名
4     $twoKeys = array_keys($two);
5     key($array);//输出当前单元的键名
6     //数组定义后,使用current()取得当前单元的值
7     $red = current($array);
8     list($red,$green) = $array;//把数组中的值赋与变量,$array = array("红色","绿色");
9     each($two);//返回数组中当前单元的键和值
　　
　　遍历数组：





1     foreach($two as $subArray);//遍历数组
2     while(list($key,$value) = each($array)){
3         echo "$key=>$value,";//使用each遍历数组
4     }
　　
　　填充数组：





    //向左、右填充数组
02     array_pad($array,+3,"shuzhi");//2参数为正从左往右填充，数值大于单元数时才填充
03     $array1 = array_fill(5,5,"test");//使用array_fill()填充这个数组的值,值为test,从第5个单元开始填充,一共填充5个单元
04     //填充数组键名
05     $keys = array('string', 5, 10, 'str');
06     $array3 = array_fill_keys($keys,"数组值");
07     //使用array_filp()函数交换键名与值
08     $speed = array_flip($speed);
09     //使用array_splice()函数替换第6个单元的值为7
10     $output = array_splice($input,6,0,7);
11     //使用array_splice()函数删除数组单元,只保留前5个单元
12     $output = array_splice($input,5);
13     $array1 = range(10,100,10); //使用range()函数的第三个参数,设置单元之间的步进值
　　
　　排序：





    shuffle($array);//将数组顺序打乱
02     //使用array_multisort()对三个数组排序
03     array_multisort($sort1,$sort2,$sort3);
04     //把这个数组进行排序,并保持索引关系
05     asort($array);
06     //把测试数组进行逆向排序,并保持索引关系
07     arsort($array);
08     //使用ksort()对数组按键名排序
09     ksort($array);
10     //使用krsort()函数按键名逆向排序
11     krsort($array);
12     //使用sort()对测试数组进行排序[以键名排列]
13     sort($array);
14     //使用natsort()排序[自然排序,以数值排列]对单元数值大小写敏感
15     natsort($array);
16     //使用natcasesort()函数排序[自然排序]但是忽略数值大小写
17     natcasesort($array);
18     //使用array_reverse()函数排序,数组单元按相反排列
19     $newArray = array_reverse($array,TRUE);//TRUE设时保留原键名
　　
　　交集、差集：





01     //使用array_diff()计算三个数组的差集[对数组数值比较]
02     $result = array_diff($dog1,$dog2,$dog3);
03     //使用array_diff_assoc()计算三个数组的差集[对数值和键名比较]
04     $result = array_diff_assoc($dog1,$dog2,$dog3);
05     //使用array_diff_key()计算三个数组的差集[比较键名]
06     $result = array_diff_key($dog1,$dog2,$dog3);
07     //使用array_intersect()计算三个数组的交集[对数组数值比较]
08     $result = array_intersect($dog1,$dog2,$dog3);
09     //使用array_intersect_assoc()计算三个数组的交集[对数值和键名比较]
10     $result = array_intersect_assoc($dog1,$dog2,$dog3);
11     //使用array_intersect_key()计算三个数组的交集[比较键名]
12     $result = array_intersect_key($dog1,$dog2,$dog3);
　　
　　合并数组：



1     //使用array_merge()函数合并数组
2     $result = array_merge($array1,$array2,$array3,$array4,$array5);
3     array_rand($input,10);//随机取出10个单元
4     count($array,COUNT_RECURSIVE);//显示数组单元数目，2参数只可为1或者COUNT_RECURSIVE,有时可遍历多维数组
　　
　　出入栈：





1     //数组出栈,后进先出，数组最后一个单元弹出
2     array_pop($array);
3     //数组入栈,将7，8两个数值添加到数组尾部
4     array_push($array，7，8);
5     //将数组开头单元移出数组
6     array_shift($array);
7     //将7，8添加入数组开头
8     array_unshift($array,7,8）;
　　
　　

　　

　　----------------------------PHP数组合并与数组连接---------------------------------

合并数组
　　array_merge()函数将数组合并到一起，返回一个联合的数组。所得到的数组以第一个输入数组参数开始，按后面数组参数出现的顺序依次迫加。其形式为：

1	array array_merge (array array1 array2…,arrayN)

　　将一个或多个数组的单元合并起来，一个数组中的值附加在前一个数组的后面。返回作为结果的数组。
　　如果输入的数组中有相同的字符串键名，则该键名后面的值将覆盖前一个值。然而，如果数组包含数字键名，后面的值将不会覆盖原来的值，而是附加到后面。
　　如果只给了一个数组并且该数组是数字索引的，则键名会以连续方式重新索引。
　　实例如下：





1     $face = array("J","Q","K","A");
2     $numbered = array("2","3","4","5","6","7","8","9");
3     $cards = array_merge($face, $numbered);
4     shuffle($cards);
5     print_r($cards);
这将返回如下所示的结果，运行代码：
1     Array ( [0] => A [1] => 4 [2] => 9 [3] => 3 [4] => K [5] => 7 [6] => 5 [7] => Q [8] => 6 [9] => 8 [10] => 2 [11] => J )
　　



递归追加数组
　　array_merge_recursive()函数与array_merge()相同，可以将两个或多个数组合并在一起，形成一个联合的数组．两 者之间 的区别在于，当某个输入数组中的某个键己经存在于结果数组中时该函数会采取不同的处理方式．array_merge()会覆盖前面存在的键/值对，替换为 当前输入数组中的键/值对，而array_merge_recursive()将把两个值合并在一起，形成一个新的数组，并以原有的键作为数组名。还有一 个数组合并的形式，就是递归追加数组。其形式为：


　　



1     array array_merge_recursive( array key,array values )
示例如下：
1     $class1 = array("John" => 100, "James" => 85);
2     $class2 = array("Micky" => 78, "John" => 45);
3     $classScores = array_merge_recursive($class1, $class2);
4     print_r($classScores);
这将返回如下结果：
1     Array ( [John] => Array ( [0] => 100 [1] => 45 ) [James] => 85 [Micky] => 78 )
　　



连接两个数组
　　array_combine()函数会得到一个新数组，它由一组提交的键和对应的值组成。其形式为：





1     array array_merge(array array1,array array2[…,array arrayN])
注意，两个输入数组必须大小相同，不能为空。示例如下：
1     $abbreviations = array("AL","AK","AZ","AR");
2     $states = array("Alabama","Alaska","Arizona","Arkansas");
3     $stateMap = array_combine($abbreviations,$states);
4     print_r($stateMap);
这会返回：
1     Array ( [AL] => Alabama [AK] => Alaska [AZ] => Arizona [AR] => Arkansas )