数组函数
1 array_change_key_case 把数组中所有键（key）更改为小写或大写。
array_change_key_case($arr,CASE_UPPER);
可选参数：
CASE_UPPER 大写
CASE_LOWER 小写
例：
$age=array("Bill"=>"60","Steve"=>"56","Mark"=>"31");
print_r(array_change_key_case($age,CASE_UPPER));
结果：Array ( [BILL] => 60 [STEVE] => 56 [MARK] => 31 )
2 array_chunk 把一个数组分割为新的数组块。
array_chunk($arr,size);
array_chunk($arr,size,true); true - 保留原始数组中的键名。
array_chunk($arr,size,false); false - 默认。每个新数组块使用从零开始的索引。
例：把数组分割为带有两个元素的数组：
$cars=array("Volvo","BMW","Toyota","Honda","Mercedes","Opel");
print_r(array_chunk($cars,2));
结果：
Array (
[0] => Array ( [0] => Volvo [1] => BMW )
[1] => Array ( [0] => Toyota [1] => Honda )
[2] => Array ( [0] => Mercedes [1] => Opel )
)
例2：把数组分割为带有两个元素的数组，并保留原始数组中的键名：
$age=array("Bill"=>"60","Steve"=>"56","Mark"=>"31","David"=>"35");
print_r(array_chunk($age,2,true));
结果：Array (
[0] => Array ( [Bill] => 60 [Steve] => 56 )
[1] => Array ( [Mark] => 31 [David] => 35 )
)
3 array_column——— 返回输入数组中某个单一列的值。
注释：返回$arr下所有键名为username的值
array_column($arr,'username');
array_column($arr,'username','id'); 保留id
例：
$a = array(
array(
'id' => 5698,
'first_name' => 'Bill',
'last_name' => 'Gates',
),
array(
'id' => 4767,
'first_name' => 'Steve',
'last_name' => 'Jobs',
)
);
$last_names = array_column($a, 'last_name');
print_r($last_names);
结果：
Array
(
[0] => Gates
[1] => Jobs
)
例2：从记录集中取出 last_name 列，用相应的 "id" 列作为键值：
$a = array(
array(
'id' => 5698,
'first_name' => 'Bill',
'last_name' => 'Gates',
),
array(
'id' => 4767,
'first_name' => 'Steve',
'last_name' => 'Jobs',
)
);
$last_names = array_column($a, 'last_name', 'id');
print_r($last_names);
结果：
Array
(
[5698] => Gates
[4767] => Jobs
)
4 array_combine——— 合并两个数组来创建一个新数组
array_combine($arr1,$arr2); $arr1做键，$arr2做值5 array_count_values——— 统计数组中所有值出现的次数。
注释：也就是说数组中的相同的值出现了几次
array_count_values（$arr）6 array_diff——— 比较数组键值（value），返回差集
注释：返回$arr1与$arr2中不重复的值,$arr1为主体
array_diff($arr1,$arr2);
array_diff($arr1,$arr2,$arr3);7 array_diff_assoc——— 比较数组的键名（key）和键值（value），返回差集
注释：返回$arr1与$arr2中不重复的键名与键值,$arr1为主体
array_diff_assoc($arr1,$arr2);
array_diff_assoc($arr1,$arr2,$arr3);8 array_diff_key——— 比较数组的键名（key），返回差集
注释：返回$arr1与$arr2中不重复的键名,$arr1为主体
array_diff_key($arr1,$arr2);
array_diff_key($arr1,$arr2,$arr3);9 array_diff_uassoc——— 比较数组的键名（key）和键值（value），返回差集(自定义函数方法)
语法：array_diff_uassoc(数组1，数组2，自定义函数);
function myfunction($a,$b)
{
if ($a===$b)
{
return 0;
}
return ($a>$b)?1:-1;
}
$a1=array("a"=>"red","b"=>"green","c"=>"blue");
$a2=array("d"=>"red","b"=>"green","e"=>"blue");
$result=array_diff_uassoc($a1,$a2,"myfunction");
print_r($result);10 array_diff_ukey——— 比较数组的键名（key），返回差集(自定义函数方法)
语法：array_diff_ukey(数组1，数组2，自定义函数);
function myfunction($a,$b)
{
if ($a===$b)
{
return 0;
}
return ($a>$b)?1:-1;
}
$a1=array("a"=>"red","b"=>"green","c"=>"blue");
$a2=array("a"=>"blue","b"=>"black","e"=>"blue");
$result=array_diff_ukey($a1,$a2,"myfunction");
print_r($result);11 array_fill——— 用给定的键值（value）填充数组。
语法：array_fill(index[起始索引],number[元素数量],value[要填充的值]);
$a1=array_fill(3,4,"blue");
print_r($a1);12 array_fill_keys——— 用给定的键名（key）填充数组。
注释：这里将$arr作为键，而对应的值就是value
array_fill_keys($arr,value);
$keys=array("a","b","c","d");
$a1=array_fill_keys($keys,"blue");
print_r($a1);13 array_filter——— 用回调函数过滤数组中的元素。
注释：比较的是ASCLL编码，返回奇数
function test_odd($var)
{
return($var & 1);
}
$a1=array("a","b",2,3,4);
print_r(array_filter($a1,"test_odd"));
结果： 3
14 array_flip——— 反转键名（key）与键值（value）
注释：将值作为键，将键作为值
array_flip($arr);15 array_intersect——— 比较数组的键值（value），返回交集
注释：返回$arr1与$arr2中相同的值,$arr1为主体
array_intersect($arr1,$arr2,$arr3...);16 array_intersect_assoc——— 比较数组的键名（key）和键值（value），返回交集
注释：返回$arr1与$arr2中相同的值,$arr1为主体
array_intersect_assoc($arr1,$arr2,$arr3...);17 array_intersect_key——— 比较数组的键名（key），返回交集
注释：返回$arr1与$arr2中相同的值,$arr1为主体
array_intersect_key($arr1,$arr2,$arr3...);18 array_intersect_uassoc——— 比较数组的键名（key）和键值（value），返回交集（自定义函数版）
语法：array_intersect_uassoc(数组1，数组2，自定义函数);
function myfunction($a,$b)
{
if ($a===$b)
{
return 0;
}
return ($a>$b)?1:-1;
}
$a1=array("a"=>"red","b"=>"green","c"=>"blue");
$a2=array("d"=>"red","b"=>"green","e"=>"blue");
$result=array_intersect_uassoc($a1,$a2,"myfunction");
print_r($result);19 array_intersect_ukey——— 比较数组的键名（key），返回交集（自定义函数版）
语法：array_intersect_ukey(数组1，数组2，自定义函数);
function myfunction($a,$b)
{
if ($a===$b)
{
return 0;
}
return ($a>$b)?1:-1;
}
$a1=array("a"=>"red","b"=>"green","c"=>"blue");
$a2=array("a"=>"blue","b"=>"black","e"=>"blue");
$result=array_intersect_ukey($a1,$a2,"myfunction");
print_r($result);20 array_key_exists——— 检查某个数组中是否存在指定的键名（key）
注释：查询a是否存在$arr的键中
array_key_exists("a",$arr)21 array_keys——— 返回数组中所有键名（key）
array_keys(array) 返回数组中所有键名
array_keys(array,value) 返回数组中value值的键名
array_keys(array,value,true) 与 value 参数一起使用。可能的值：
true - 返回带有指定键值的键名。依赖类型，数字 5 与字符串 "5" 是不同的。
false - 默认值。不依赖类型，数字 5 与字符串 "5" 是相同的。22 array_map()——— 自定义函数作用到数组中的每个值上，并返回新的值的数组。
注释：数组经过自定义函数的判断后，返回新值
function myfunction($v)
{
return($v*$v);
}
$a=array(1,2,3,4,5);
print_r(array_map("myfunction",$a));23 array_merge() ——— 用于把一个或多个数组合并为一个数组。
注释：合并多个数组，如果有相同的键名，后者将会替换前者
array_merge($arr1,$arr2,$arr3...)
24 array_merge_recursive() ——— 用于把一个或多个数组合并为一个数组。
注释：array_merge_recursive() 不会进行键名覆盖，而是将多个相同键名的值递归组成一个数组。如果有相同的键名，那就组成一个二维数组
$a1=array("a"=>"red","b"=>"green");
$a2=array("c"=>"blue","b"=>"yellow");
print_r(array_merge_recursive($a1,$a2));
25 array_multisort()——— 返回一个排序数组。
array_multisort(规定数组,可选。规定排列顺序，可选。规定排序类型。)；
规定排列顺序
SORT_ASC - 默认。按升序排列 (A-Z)。
SORT_DESC - 按降序排列 (Z-A)。
规定排序类型
SORT_REGULAR - 默认。把每一项按常规顺序排列（Standard ASCII，不改变类型）。
SORT_NUMERIC - 把每一项作为数字来处理。
SORT_STRING - 把每一项作为字符串来处理。
SORT_LOCALE_STRING - 把每一项作为字符串来处理，基于当前区域设置（可通过 setlocale() 进行更改）。
SORT_NATURAL - 把每一项作为字符串来处理，使用类似 natsort() 的自然排序。
SORT_FLAG_CASE - 可以结合（按位或）SORT_STRING 或 SORT_NATURAL 对字符串进行排序，不区分大小写。
26 array_pad() ——— 将指定数量的带有指定值的元素插入到数组中。
语法：array_pad($arr,size($arr全部的元素个数),"value(要补的元素值)")
如果size=负数，那么value值就会从0开始排序
$a=array("red","green");
print_r(array_pad($a,5,"blue"));
28 array_pop（）———删除数组中的最后一个元素。
语法：array_pop(array)
$a=array("red","green","blue");
array_pop($a);
结果：blue 被删除29 array_product（）———计算并返回数组的乘积。
语法：array_product(array)
$a=array(5,5);
echo(array_product($a));
结果：2530 array_push（）———向数组尾部插入一个或多个元素。
语法：array_push($arr,值1,可选值2...)
$a=array("red","green");
array_push($a,"blue","yellow");
print_r($a);
结果：blue,yellow被插入到$a数组后面31 array_rand() ———返回数组中的一个随机键名。
注释：返回$a中随机的3个键名，输出对应键名的值
$a=array("1","2","3","4","5");
$random_keys=array_rand($a,3);
echo $a[$random_keys[0]]."
";
echo $a[$random_keys[1]]."
";
echo $a[$random_keys[2]];32 array_reduce（）发送数组中的值到用户自定义函数，并返回一个字符串。
语法：array_reduce(数组,传入的函数,【可选】发送到函数处理的第一个值。)
例1：
function myfunction($v1,$v2)
{
return $v1 . "-" . $v2;
}
$a=array("Dog","Cat","Horse");
print_r(array_reduce($a,"myfunction"));
结果：Dog-Cat-Horse
例2：
function myfunction($v1,$v2)
{
return $v1 . "-" . $v2;
}
$a=array("Dog","Cat","Horse");
print_r(array_reduce($a,"myfunction",5)); 这个5可以不在数组之内
结果：5-Dog-Cat-Horse
例3：
$b = 10;
function myfunction($v1,$v2)
{
return $v1 . "-" . $v2;
}
$a=array("Dog","Cat","Horse");
print_r(array_reduce($a,"myfunction",$b));;
结果：10-Dog-Cat-Horse
33 array_replace() 使用第2个数组的值替换第1个数组的值。
语法：array_replace($arr1,$arr2,$arr3...)
注释：$a2把$a1的所有值都替换了，最后一位数组，将替换前面的所有数组
例1：
$a1=array("red","green");
$a2=array("blue","yellow");
print_r(array_replace($a1,$a2));
结果：Array ( [0] => blue [1] => yellow )
例2：
如果第2个数组指定了索引，第1个数组没有指定，那么会按照第2个数组的索引来取出第1个数组对应的键值
$a1=array("1","2","3","5");
$a2=array(0=>"1",3=>"4");
print_r(array_replace($a1,$a2));
输出：Array ( [0] => 1 [1] => 2 [2] => 3 [3] => 4 )34 array_replace_recursive() 递归地使用第2个数组的值替换第1个数组的值。
注释：2维数组都能给你替换掉
语法：array_replace_recursive(数组1,数组2,数组3...)
$a1=array("a"=>array("red"),"b"=>array("green","blue"),);
$a2=array("a"=>array("yellow"),"b"=>array("black"));
print_r(array_replace_recursive($a1,$a2));
array_replace() 与 array_replace_recursive() 之间的不同：
array_replace() 强制替换第2个数组的值
array_replace_recursive() 如果第1个数组存在第2个数组不同的索引，那么结果也包含第一个数组的值
35 array_reverse（）返回翻转顺序的数组。
注释：将数组的最后1位变成第1位，将第1位变成最后1位
语法：array_reverse(array,preserve)
preserve：可选
可选。规定是否保留原始数组的键名。
如果设置为 TRUE 会保留数字的键。 非数字的键则不受这个设置的影响，总是会被保留。
可能的值：true，false
36 array_search（）在数组中搜索某个键值（value），并返回对应的键名。（key）
语法：array_search(value,array,strict)
strict 如果该参数被设置为 TRUE，则函数在数组中搜索数据类型和值都一致的元素。
可能的值：true false - 默认
如果设置为 true，则在数组中检查给定值的类型，数字 5 和字符串 5 是不同的。
$a=array("a"=>"red","b"=>"green","c"=>"blue");
echo array_search("red",$a);
37 array_shift（）用于删除数组中的第一个元素，并返回被删除的元素。
注释：如果键名是数字的，所有元素都将获得新的键名，从0开始，并以1递增
语法：array_shift(array)
38 array_slice() 返回数组中的选定部分。
语法：array_slice(array,start,length,preserve)
start 规定取出元素的开始位置。如果是正数，刚从前往后取。如果是负数，则从后往前取
length 截取几位
preserve 规定函数是保留键名还是重置键名。可能的值：true - 保留键名 false - 默认。重置键名
$a=array("red","green","blue","yellow","brown");
print_r(array_slice($a,2));39 array_splice() 从数组中移除选定的元素，并用新元素取代它。函数也将返回被移除元素的数组。
语法：array_splice($arr1,start,length,array2)
$arr1 数组。
start 规定取出元素的开始位置。如果是正数，刚从前往后移除。如果是负数，则从后往前移除
length 规定被移除的元素个数
$arr2 插入$arr1的数组。如果只有一个元素，则可以设置为字符串
提示：如果函数没有移除任何元素（length=0），则替代数组将从 start 参数的位置插入（参见实例 2）。
例1：
$a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
$a2=array("a"=>"purple","b"=>"orange");
array_splice($a1,0,2,$a2);
结果：Array ( [0] => purple [1] => orange [c] => blue [d] => yellow )
例2：
与前面部分的实例相同，但是输出返回的数组：
$a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
$a2=array("a"=>"purple","b"=>"orange");
print_r(array_splice($a1,0,2,$a2));
结果：Array ( [a] => red [b] => green )
为什么是这两个结果呢？因为他们被移除了，所以出来了
例3：带有设置为 0 的 length 参数：
$a1=array("0"=>"red","1"=>"green");
$a2=array("0"=>"purple","1"=>"orange");
array_splice($a1,1,0,$a2);
print_r($a1);
结果：Array ( [0] => red [1] => purple [2] => orange [3] => green )
译：0就不移除呗，然后插入索引键名为1的，那肯定就是这个答案了
40 array_sum() 返回数组中所有值的和。
语法：array_sum($arr)
$a=array(5,15,25);
echo array_sum($a);
结果：4541 array_udiff() 用于比较两个（或更多个）数组的键值（value） ，并返回差集。
语法：array_udiff(数组1,数组2,数组3...,自定义函数),像这样的比较，数组1一般都是老大
function myfunction($a,$b)
{
if ($a===$b)
{
return 0;
}
return ($a>$b)?1:-1;
}
$a1=array("a"=>"red","b"=>"green","c"=>"blue");
$a2=array("a"=>"blue","b"=>"black","e"=>"blue");
$result=array_udiff($a1,$a2,"myfunction");
print_r($result);
结果：Array ( [a] => red [b] => green )42 array_udiff_assoc() 用于比较两个（或更多个）数组的键名（key）和键值（value），并返回差集。
语法：array_udiff_assoc()(数组1,数组2,数组3...,自定义函数),像这样的比较，数组1一般都是老大
function myfunction($a,$b)
{
if ($a===$b)
{
return 0;
}
return ($a>$b)?1:-1;
}
$a1=array("a"=>"red","b"=>"green","c"=>"blue");
$a2=array("a"=>"red","b"=>"blue","c"=>"green");
$result=array_udiff_assoc($a1,$a2,"myfunction");
print_r($result);43 array_udiff_uassoc() 用于比较两个（或更多个）数组的键名（key）和键值（value），并返回差集。
注释：该函数使用两个用户自定义函数进行比较；第一个函数比较键名，第二个函数比较键值！
语法：array_udiff_uassoc(数组1,数组2,数组3...,自定义函数1,自定义函数2)
自定义函数1 === key
自定义函数2 === value
function myfunction_key($a,$b)
{
if ($a===$b)
{
return 0;
}
return ($a>$b)?1:-1;
}
function myfunction_value($a,$b)
{
if ($a===$b)
{
return 0;
}
return ($a>$b)?1:-1;
}
$a1=array("a"=>"red","b"=>"green","c"=>"blue");
$a2=array("a"=>"red","b"=>"green","c"=>"green");
$result=array_udiff_uassoc($a1,$a2,"myfunction_key","myfunction_value");
print_r($result);44 array_uintersect() 用于比较两个（或更多个）数组的键值（value） ，并返回交集。
语法：array_uintersect(array1,array2,array3...,myfunction)
function myfunction($a,$b)
{
if ($a===$b)
{
return 0;
}
return ($a>$b)?1:-1;
}
$a1=array("a"=>"red","b"=>"green","c"=>"blue");
$a2=array("a"=>"blue","b"=>"black","e"=>"blue");
$result=array_uintersect($a1,$a2,"myfunction");
print_r($result);45 array_uintersect_assoc() 用于比较两个（或更多个）数组的键名（key）和键值（value） ，并返回交集。
语法：array_uintersect_assoc(array1,array2,array3...,myfunction)
function myfunction($a,$b)
{
if ($a===$b)
{
return 0;
}
return ($a>$b)?1:-1;
}
$a1=array("a"=>"red","b"=>"green","c"=>"blue");
$a2=array("a"=>"red","b"=>"blue","c"=>"green");
$result=array_uintersect_assoc($a1,$a2,"myfunction");
print_r($result);46 array_uintersect_uassoc() 用于比较两个（或更多个）数组的键名（key）和键值（value），并返回交集。
注释：该函数使用两个用户自定义函数进行比较；第一个函数比较键名，第二个函数比较键值！
array_uintersect_uassoc(array1,array2,array3...,myfunction_key,myfunction_value)
function myfunction_key($a,$b)
{
if ($a===$b)
{
return 0;
}
return ($a>$b)?1:-1;
}
function myfunction_value($a,$b)
{
if ($a===$b)
{
return 0;
}
return ($a>$b)?1:-1;
}
$a1=array("a"=>"red","b"=>"green","c"=>"blue");
$a2=array("a"=>"red","b"=>"green","c"=>"green");
$result=array_uintersect_uassoc($a1,$a2,"myfunction_key","myfunction_value");
print_r($result);47 array_unique() 用于移除数组中重复的值。如果两个或更多个数组值相同，只保留第一个值，其他的值被移除。
语法：array_unique(array)
sortingtype：可选
SORT_STRING - 默认。把每一项作为字符串来处理。
SORT_REGULAR - 把每一项按常规顺序排列（Standard ASCII，不改变类型）。
SORT_NUMERIC - 把每一项作为数字来处理。
SORT_LOCALE_STRING - 把每一项作为字符串来处理，基于当前区域设置（可通过 setlocale() 进行更改）。
$a=array("a"=>"red","b"=>"green","c"=>"red");
print_r(array_unique($a));48 array_unshift() 在数组头插入新元素
语法：array_unshift(数组,值1,值2,值3...)
49 array_values（）返回包含数组中所有的值的数组。
语法：array_values(array)
提示：被返回的数组将使用数值键，从0开始且以1递增。
$a=array("Name"=>"Peter","Age"=>"41","Country"=>"USA");
print_r(array_values($a));
结果：Array ( [0] => Peter [1] => 41 [2] => USA )50 array_walk（）对数组中的每个元素应用用户自定义函数。在函数中，数组的键名（key）和键值（value）是参数。
语法：array_walk(array,myfunction,parameter...)
例1：
function myfunction($value,$key)
{
echo "The key $key has the value $value
";
}
$a=array("a"=>"red","b"=>"green","c"=>"blue");
array_walk($a,"myfunction");
例2：
parameter：可选
规定用户自定义函数的参数，您可以为函数设置一个或多个参数。
function myfunction($value,$key,$p)
{
echo "$key $p $value
";
}
$a=array("a"=>"red","b"=>"green","c"=>"blue");
array_walk($a,"myfunction","的颜色是");
结果：
a的颜色是red
b的颜色是green
c的颜色是blue
例：3
改变数组元素的值（请注意＆$ value）：
function myfunction(&$value,$key)
{
$value="yellow";
}
$a=array("a"=>"red","b"=>"green","c"=>"blue");
array_walk($a,"myfunction");
print_r($a);
结果：Array ( [a] => yellow [b] => yellow [c] => yellow )
51 array_walk_recursive（） 该函数与array_walk（）函数的不同在于可以操作更深的数组（一个数组中含有另一个数组）。
语法：array_walk_recursive(array,myfunction,parameter...)
function myfunction($value,$key)
{
echo " $key ----- $value
";
}
$a1=array("a"=>"red","b"=>"green");
$a2=array($a1,"1"=>"blue","2"=>"yellow");
array_walk_recursive($a2,"myfunction");
结果：
a ----- red
b ----- green
1 ----- blue
2 ----- yellow
52 arsort（）对关联数组按照键值（value）进行降序排序（从高到低排序）。
语法：arsort(array,sortingtype);
sortingtype 可选。规定如何排列数组的元素/项目。
0 = SORT_REGULAR - 默认。把每一项按常规顺序排列（Standard ASCII，不改变类型）。
1 = SORT_NUMERIC - 把每一项作为数字来处理。
2 = SORT_STRING - 把每一项作为字符串来处理。
3 = SORT_LOCALE_STRING - 把每一项作为字符串来处理，基于当前区域设置（可通过 setlocale() 进行更改）。
4 = SORT_NATURAL - 把每一项作为字符串来处理，使用类似 natsort() 的自然排序。
5 = SORT_FLAG_CASE - 可以结合（按位或）SORT_STRING 或 SORT_NATURAL 对字符串进行排序，不区分大小写。
例：
$age=array("a"=>"35","b"=>"37","c"=>"43");
arsort($age);
foreach($age as $k=>$v)
{
echo "Key=" . $k . ", Value=" . $v;
echo "
";
}
结果：
Key=c, Value=43
Key=b, Value=37
Key=a, Value=35
53 asort（）对关联数组按照键值（value）进行升序排序（从低到高排序）。
语法：asort(array,sortingtype);
sortingtype 可选。规定如何排列数组的元素/项目。
0 = SORT_REGULAR - 默认。把每一项按常规顺序排列（Standard ASCII，不改变类型）。
1 = SORT_NUMERIC - 把每一项作为数字来处理。
2 = SORT_STRING - 把每一项作为字符串来处理。
3 = SORT_LOCALE_STRING - 把每一项作为字符串来处理，基于当前区域设置（可通过 setlocale() 进行更改）。
4 = SORT_NATURAL - 把每一项作为字符串来处理，使用类似 natsort() 的自然排序。
5 = SORT_FLAG_CASE - 可以结合（按位或）SORT_STRING 或 SORT_NATURAL 对字符串进行排序，不区分大小写。
例：
$age=array("a"=>"35","b"=>"37","c"=>"43");
asort($age);
foreach($age as $k=>$v)
{
echo "Key=" . $k . ", Value=" . $v;
echo "
";
}
结果：
Key=c, Value=43
Key=b, Value=37
Key=a, Value=35
54 compact（）创建一个包含变量名（$data）和它们的值（value）的数组。
compact(var1,var2...)
var1 必需。可以是带有变量名的字符串，或者是一个变量数组。
var2,... 可选。可以是带有变量名的字符串，或者是一个变量数组。允许多个参数。
例1：
$firstname = "Peter";
$lastname = "Griffin";
$age = "41";
$result = compact("firstname", "lastname", "age");
print_r($result);
结果：Array ( [firstname] => Peter [lastname] => Griffin [age] => 41 )
例2：
使用没有对应变量名的字符串，以及一个变量名数组：（就是说，你可以把带有变量名的数组，存到变量里使用）
$firstname = "Peter";
$lastname = "Griffin";
$age = "41";
$name = array("firstname", "lastname");
$result = compact($name, "location", "age");
print_r($result);
55 count（）返回数组中元素的个数。
语法：count(array,mode);
mode 可选。规定函数的模式。可能的值：
0 - 默认。不计算多维数组中的所有元素。
1 - 递归地计算数组中元素的数目（计算多维数组中的所有元素）。
56 current（）函数返回数组中的当前元素的值
默认指向第0个元素
每个数组中都有一个内部的指针指向它的 “当前” 元素，初始指向插入到数组中的第一个元素。
提示：该函数不会移动数组内部指针。
例：
$people = array("1", "2", "3", "4");
echo current($people) . "
";
结果：1
57 each（）返回当前元素的键名（value）和键值（value），并将内部指针向前移动。
语法：each(array)
例1：该元素的键名和键值返回到带有四个元素的数组中。两个元素（1和键值）包含键值，两个元素（0和键）包含键名。
$people = array("Peter", "Joe", "Glenn", "Cleveland");
print_r (each($people));
结果：Array ( [1] => Peter [value] => Peter [0] => 0 [key] => 0 )
例2:通过循环输出整个数组
$people = array("Peter", "Joe", "Glenn", "Cleveland");
reset($people);
while (list($key, $val) = each($people))
{
echo "$key => $val
";
}
结果：
0 => Peter
1 => Joe
2 => Glenn
3 => Cleveland
58 end（）将内部指针指向数组中的最后一个元素，并输出。
语法：end(array)
例：
$people = array("Peter", "Joe", "Glenn", "Cleveland");
echo current($people) . "
";
echo end($people);
结果：
Peter
Cleveland
59 extract() 从数组中将变量导入到当前的符号表。
该函数使用数组键名(key)作为变量名，使用数组键值(value)作为变量值。
语法：extract(array,extract_rules,prefix)
extract_rules 可选。函数将检查每个键名是否为合法的变量名，同时也检查和符号表中已存在的变量名是否冲突。对不合法和冲突的键名的处理将根据此参数决定。
EXTR_OVERWRITE - 默认。如果有冲突，则覆盖已有的变量。
EXTR_SKIP - 如果有冲突，不覆盖已有的变量。
EXTR_PREFIX_SAME - 如果有冲突，在变量名前加上前缀 prefix。
EXTR_PREFIX_ALL - 给所有变量名加上前缀 prefix。
EXTR_PREFIX_INVALID - 仅在不合法或数字变量名前加上前缀 prefix。
EXTR_IF_EXISTS - 仅在当前符号表中已有同名变量时，覆盖它们的值。其它的都不处理。
EXTR_PREFIX_IF_EXISTS - 仅在当前符号表中已有同名变量时，建立附加了前缀的变量名，其它的都不处理。
EXTR_REFS - 将变量作为引用提取。导入的变量仍然引用了数组参数的值。
prefix 可选。如果 extract_rules 参数的值是 EXTR_PREFIX_SAME、EXTR_PREFIX_ALL、 EXTR_PREFIX_INVALID 或 EXTR_PREFIX_IF_EXISTS，则 prefix 是必需的。
该参数规定了前缀。前缀和数组键名之间会自动加上一个下划线。
例2：使用所有的参数：
如果$a与外面$a变量有冲突，那么数组中的a就该加上EXTR_PREFIX_SAME，并且要添加第3个可选值，给它一个前缀名prefix
将键值 "Cat"、"Dog" 和 "Horse" 赋值给变量 $a、$b 和 $c：
$a = "a";
$my_array = array("a" => "aa", "b" => "b", "c" => "c");
extract($my_array, EXTR_PREFIX_SAME, "dup");
echo "$a = $a; $b = $b; $c = $c; $dup_a = $dup_a";
结果：$a = a;$b=b;$c=c;$dup_a = aa;
60 in_array（）搜索数组中是否存在指定的值。
bool in_array （mixed $ needle ，array $ haystack [，bool $ strict = FALSE ] ）
needle 必需。规定要在数组搜索的值。
array 必需。规定要搜索的数组。
strict 可选。如果该参数设置为 TRUE，则 in_array() 函数检查搜索的数据与数组的值的类型是否相同。
例1：
$people = array("Peter", "Joe", "Glenn", "Cleveland");
if (in_array("Glenn", $people))
{
echo "Match found";
}
else
{
echo "Match not found";
}
结果：Match found
例2 使用所有的参数：
$people = array("Peter", "Joe", "Glenn", "Cleveland", 23);
if (in_array(23, $people, TRUE))
{
echo "Match found
";
}
else
{
echo "Match not found
";
}
结果：Match found
61 key（）从当前内部指针位置返回元素键名（key）
语法：key(array)
例：
$people=array("Peter","Joe","Glenn","Cleveland");
echo "The key from the current position is: " . key($people);
结果：The key from the current position is: 0
62 krsort（）对关联数组按照键名（key）进行降序排序（从高到低）。
语法：krsort(array,sortingtype);
注：如果是键名是字母，则按a-z,A-Z排序
sortingtype 可选。规定如何排列数组的元素/项目。可能的值：
0 = SORT_REGULAR - 默认。把每一项按常规顺序排列（Standard ASCII，不改变类型）。
1 = SORT_NUMERIC - 把每一项作为数字来处理。
2 = SORT_STRING - 把每一项作为字符串来处理。
3 = SORT_LOCALE_STRING - 把每一项作为字符串来处理，基于当前区域设置（可通过 setlocale() 进行更改）。
4 = SORT_NATURAL - 把每一项作为字符串来处理，使用类似 natsort() 的自然排序。
5 = SORT_FLAG_CASE - 可以结合（按位或）SORT_STRING 或 SORT_NATURAL 对字符串进行排序，不区分大小写。
例：
$age=array("0"=>"35","1"=>"37","2"=>"43");
krsort($age);
foreach($age as $x=>$x_value)
{
echo "Key=" . $x . ", Value=" . $x_value;
echo "
";
}
结果：
Key=2, Value=43
Key=1, Value=37
Key=0, Value=35
63 ksort（）对关联数组按照键名（key）进行升序排序（从低到高）。
语法：ksort(array,sortingtype);
注：如果是键名是字母，则按a-z,A-Z排序
sortingtype 可选。规定如何排列数组的元素/项目。可能的值：
0 = SORT_REGULAR - 默认。把每一项按常规顺序排列（Standard ASCII，不改变类型）。
1 = SORT_NUMERIC - 把每一项作为数字来处理。
2 = SORT_STRING - 把每一项作为字符串来处理。
3 = SORT_LOCALE_STRING - 把每一项作为字符串来处理，基于当前区域设置（可通过 setlocale() 进行更改）。
4 = SORT_NATURAL - 把每一项作为字符串来处理，使用类似 natsort() 的自然排序。
5 = SORT_FLAG_CASE - 可以结合（按位或）SORT_STRING 或 SORT_NATURAL 对字符串进行排序，不区分大小写。
例：
$age=array("0"=>"35","1"=>"37","2"=>"43");
ksort($age);
foreach($age as $x=>$x_value)
{
echo "Key=" . $x . ", Value=" . $x_value;
echo "
";
}
结果：
Key=0, Value=35
Key=1, Value=37
Key=2, Value=43
64 list（）用于一次操作中给一组变量赋值
语法：list(var1,var2...)
var1 必需。第一个需要赋值的变量。
var2,... 可选。更多需要赋值的变量。
例1：
$my_array = array("Dog","Cat","Horse");
list($a, $b, $c) = $my_array;
echo "$a, $b ,$c";
结果：Dog,Cat,Horse
例2：使用第一个和第三个变量：
$my_array = array("Dog","Cat","Horse");
list($a, , $c) = $my_array;
echo "$a,$c";
结果：Dog,Horse
65 natcasesort() 用”自然排序”算法对数组进行排序。键值（value）保留它们原始的键名（key）。
在自然排序算法中，数字 2 小于 数字 10。在计算机排序算法中，10 小于 2，因为 "10" 中的第一个数字小于 2。
该函数不区分大小写。（大写和小写分开）
如果成功，该函数返回 TRUE，如果失败则返回 FALSE。
语法：natcasesort(array)
例：
先判断字母大小写，再判断数字大小
$temp_files = array("temp15.txt","Temp10.txt",
"temp1.txt","Temp22.txt","temp2.txt");
natcasesort($temp_files);
echo "Natural order case insensitve: ";
print_r($temp_files);
结果：
Natural order case insensitve:
Array
(
[2] => temp1.txt
[4] => temp2.txt
[0] => Temp10.txt
[3] => temp15.txt
[1] => Temp22.txt
)
66 natsort（）用“自然排序”算法对数组进行排序。键值（value）保留它们原始的键名（key）。
语法：natsort(array)
区分大小写
$temp_files = array("temp15.txt","Temp10.txt",
"temp1.txt","Temp22.txt","temp2.txt");
natsort($temp_files);
echo "Natural order: ";
print_r($temp_files);
echo "
";
结果：
Natural order:
Array
(
[0] => Temp10.txt
[1] => Temp22.txt
[2] => temp1.txt
[4] => temp2.txt
[3] => temp15.txt
)
67 next（）将内部指针指向数组中的下一个元素，并输出。
语法：next(array)
例：
$people = array("Peter", "Joe", "Glenn", "Cleveland");
echo current($people) . "
";
echo next($people);
结果：
Peter
Joe
68 pos（）返回数组中的当前元素的值。
该函数是 current() 函数的别名。
例：
$people = array("Peter", "Joe", "Glenn", "Cleveland");
echo pos($people) . "
";
结果：Peter69 prev（）将内部指针指向数组中的上一个元素，并输出。
$people = array("Peter", "Joe", "Glenn", "Cleveland");
echo current($people) . "
";
echo next($people) . "
";
echo prev($people);
结果：Peter
70 range（）创建一个包含指定范围的元素的数组。
该函数返回一个包含从低到高之间的元素的数组。
语法：range(low,high,step)
low 必需。规定数组元素的最小值。
high 必需。规定数组元素的最大值。
step 可选。规定元素之间的步进制。默认是 1。
例1：
$number = range(0,5);
print_r ($number);
结果：Array ( [0] => 0 [1] => 1 [2] => 2 [3] => 3 [4] => 4 [5] => 5 )
例2：
$number = range(0,50,10);
print_r ($number);
结果：Array ( [0] => 0 [1] => 10 [2] => 20 [3] => 30 [4] => 40 [5] => 50 )
例3：
$letter = range("a","d");
print_r ($letter);
结果：Array ( [0] => a [1] => b [2] => c [3] => d )
71 reset（）函数将内部指针指向数组中的第一个元素，并输出
语法：reset(array)
$people = array("Peter", "Joe", "Glenn", "Cleveland");
echo current($people) . "
";
echo next($people) . "
";
echo reset($people);
结果：Peter
72 rsort（）函数对数值数组进行降序排序（从高到低）。
语法：rsort(array,sortingtype);
sortingtype 可选。规定如何排列数组的元素/项目。可能的值：
0 = SORT_REGULAR - 默认。把每一项按常规顺序排列（Standard ASCII，不改变类型）。
1 = SORT_NUMERIC - 把每一项作为数字来处理。
2 = SORT_STRING - 把每一项作为字符串来处理。
3 = SORT_LOCALE_STRING - 把每一项作为字符串来处理，基于当前区域设置（可通过 setlocale() 进行更改）。
4 = SORT_NATURAL - 把每一项作为字符串来处理，使用类似 natsort() 的自然排序。
5 = SORT_FLAG_CASE - 可以结合（按位或）SORT_STRING 或 SORT_NATURAL 对字符串进行排序，不区分大小写。
例1：
$cars=array("Volvo","BMW","Toyota");
rsort($cars);
$clength=count($cars);
for($x=0;$x<$clength;$x++)
{
echo $cars[$x];
echo "
";
}
结果：
Volvo
Toyota
BMW
例2：这里本人的理解是按照键值上面的数字大小排序的。
把每一项作为数字来处理，并对数组$ cars中的元素进行降序排序：
$cars=array("Volvo","BMW","Toyota");
rsort($cars,SORT_NUMERIC);
$clength=count($cars);
for($x=0;$x<$clength;$x++)
{
echo $cars[$x];
echo "
";
}
结果：
Toyota
BMW
Volvo
73 shuffle（）函数把数组中的元素按随机顺序重新排列。
语法：shuffle(array)
例1：
$my_array = array("red","green","blue","yellow","purple");
shuffle($my_array);
print_r($my_array);
该函数为数组中的元素分配新的键名，已存在的键名将被删除
例2：
$my_array = array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow","e"=>"purple");
shuffle($my_array);
print_r($my_array);
74 sizeof（）函数返回数组中元素的数目。
sizeof（）函数是count（）函数的别名。
语法：sizeof(array,mode);
mode 可选。规定函数的模式。可能的值：
0 - 默认。不计算多维数组中的所有元素。
1 - 递归地计算数组中元素的数目（计算多维数组中的所有元素）。
75 sort（）函数对索引数组进行升序排序。（从低到高）。
语法：sort(array,sortingtype);
sortingtype 可选。规定如何排列数组的元素/项目。可能的值：
0 = SORT_REGULAR - 默认。把每一项按常规顺序排列（Standard ASCII，不改变类型）。
1 = SORT_NUMERIC - 把每一项作为数字来处理。
2 = SORT_STRING - 把每一项作为字符串来处理。
3 = SORT_LOCALE_STRING - 把每一项作为字符串来处理，基于当前区域设置（可通过 setlocale() 进行更改）。
4 = SORT_NATURAL - 把每一项作为字符串来处理，使用类似 natsort() 的自然排序。
5 = SORT_FLAG_CASE - 可以结合（按位或）SORT_STRING 或 SORT_NATURAL 对字符串进行排序，不区分大小写。
例：对数组$numbers数字中的元素按数字进行升序排序：
$numbers=array(4,6,2,22,11);
sort($numbers);
结果：
2
4
6
11
22
76 uasort（）使用用户自定义的比较函数对数组按键值（value）进行排序。
语法：uasort(array,myfunction);
myfunction 可选。
一个定义了可调用比较函数的字符串。如果第一个参数 <, =, > 第二个参数，相应地比较函数必须返回一个 <, =, > 0 的整数。
例：
function my_sort($a,$b)
{
if ($a==$b) return 0;
return ($a<$b)?-1:1;
}
$arr=array("a"=>4,"b"=>2,"c"=>8,d=>"6");
uasort($arr,"my_sort");
foreach($arr as $x=>$x_value)
{
echo "Key=" . $x . ", Value=" . $x_value;
echo "
";
}
结果：
Key=b, Value=2
Key=a, Value=4
Key=d, Value=6
Key=c, Value=8
77 uksort（）函数使用用户自定义的比较函数对数组按键名（key）进行排序。
语法：uksort(array,myfunction);
myfunction 可选。
一个定义了可调用比较函数的字符串。如果第一个参数 <, =, > 第二个参数，相应地比较函数必须返回一个 <, =, > 0 的整数。
例：
function my_sort($a,$b)
{
if ($a==$b) return 0;
return ($a<$b)?-1:1;
}
$arr=array("a"=>4,"b"=>2,"c"=>8,d=>"6");
uksort($arr,"my_sort");
foreach($arr as $x=>$x_value)
{
echo "Key=" . $x . ", Value=" . $x_value;
echo "
";
}
结果：
Key=a, Value=4
Key=b, Value=2
Key=c, Value=8
Key=d, Value=6
78 usort() 使用用户自定义的比较函数对数组进行排序。
语法：usort(array,myfunction);
myfunction 可选。
一个定义了可调用比较函数的字符串。如果第一个参数 <, =, > 第二个参数，相应地比较函数必须返回一个 <, =, > 0 的整数。
例：
function my_sort($a,$b)
{
if ($a==$b) return 0;
return ($a<$b)?-1:1;
}
$a=array(4,2,8,6);
usort($a,"my_sort");
$arrlength=count($a);
for($x=0;$x<$arrlength;$x++)
{
echo $a[$x];
echo "
";
}
结果：
2
4
6
8