PHP内置方法大全--数组篇

数组篇

---

PHP 5 Array 函数

函数 描述

函数	说明
array()	创建数组
array_change_key_case()	把数组中所有键更改为小写或大写
array_chunk()	把一个数组分割为新的数组块
array_column()	返回输入数组中某个单一列的值
array_combine()	通过合并两个数组来创建一个新数组
array_count_values()	用于统计数组中所有值出现的次数。
array_diff()	比较数组，返回差集（只比较值）。
array_diff_assoc()	比较数组，返回差集（比较键名和键值）。
array_diff_key()	比较数组，返回差集（只比较键名）。
array_diff_uassoc()	比较数组，返回差集（比较键名和键值，使用用户自定义的键名比较函数）。
array_diff_ukey()	比较数组，返回差集（只比较键名，使用用户自定义的键名比较函数）。
array_fill()	用给定的键值填充数组。
array_fill_keys()	用指定键名的给定键值填充数组。
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_replace()	使用后面数组的值替换第一个数组的值。
array_replace_recursive()	递归地使用后面数组的值替换第一个数组的值。
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()	使用用户自定义的比较函数对数组进行排序。

array_change_key_case()

将数组的所有的键转换为大写字母：

$age=array("Bill"=>"60","Steve"=>"56","Mark"=>"31");
print_r(array_change_key_case($age,CASE_UPPER));

定义和用法

• array_change_key_case() 函数将数组的所有的键都转换为大写字母或小写字母。
  数组的数字索引不发生变化。如果未提供可选参数（即第二个参数），则默认转换为小写字母。

• 注释：如果在运行该函数时两个或多个键相同，则最后的元素会覆盖其他元素

array_chunk()

把数组分割为带有两个元素的数组，并保留原始数组中的键名：

$age=array("Bill"=>"60","Steve"=>"56","Mark"=>"31","David"=>"35");
print_r(array_chunk($age,2,true));

• 第三个参数，可以省略，默认false（不保留原有键名，生成索引数组）

array_column()

从记录集中取出 last_name 列，用相应的 “id” 列作为键值：

$a = array(
        array(
            'id' => 5698,
            'first_name' => 'Bill',
            'last_name' => 'Gates',
        ),
        array(
            'id' => 4767,
            'first_name' => 'Steve',
            'last_name' => 'Jobs',
        )
        array(
            'id' => 3809,
            'first_name' => 'Mark',
            'last_name' => 'Zuckerberg',
        )
    );

$last_names = array_column($a, 'last_name', 'id');
print_r($last_names);

//输出
Array(
  [5698] => Gates
  [4767] => Jobs
  [3809] => Zuckerberg
)

• 第三参数不填写，返回索引数组

array_combine()

通过合并两个数组来创建一个新数组，其中的一个数组元素为键名，另一个数组元素为键值：

$key = array("Bill","Steve","Mark");
$value = array("60","56","31");

$c=array_combine($key, $value);

//输出
array("Bill"=>'60', "Steve"=>'56', "Mark"=>'31');

• key 键名数组
• value 键值数组

array_count_values()

对数组中的所有值进行计数：

$a=array("A","Cat","Dog","A","Dog");
print_r(array_count_values($a));

• 本函数返回一个数组，其元素的键名是原数组的值，键值是该值在原数组中出现的次数。

array_diff()

比较多个数组的值，并返回差集：

$a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow"，"f"=>"yellow");
$a2=array("e"=>"red","f"=>"green","g"=>"blue");

$result=array_diff($a1,$a2);

//输出
array("d"=>"yellow"，"f"=>"yellow");

• array_diff 是对比两个（或以上数组）的值的差集，注意是对比数组的值，和数组的键无关

  扫描二维码关注公众号，回复： 69905 查看本文章

• 是以第一个数组为对比对象，找上在第一个数组里有但其他数组里没有的值（可以同值但不同键的多个）

array_diff_assoc()

该函数比较两个（或更多个）数组的键名和键值，并返回一个差集数组

$a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
$a2=array("a"=>"red","f"=>"green","g"=>"blue");
$a3=array("h"=>"red","b"=>"green","g"=>"blue");

$result=array_diff_assoc($a1,$a2,$a3);

//输出
Array ( [c] => blue [d] => yellow )

• 是以第一个数组为对比对象，找上在第一个数组里有但其他数组里没有的，键和值需要一起比对

array_diff_key()

该函数比较两个（或更多个）数组的键名，并返回一个差集数组

$a1=array("a"=>"red","b"=>"green","c"=>"blue");
$a2=array("c"=>"yellow","d"=>"black","e"=>"brown");
$a3=array("f"=>"green","c"=>"purple","g"=>"red");

$result=array_diff_key($a1,$a2,$a3);

//输出
Array ( [a] => red [b] => green )

• 是以第一个数组为对比对象，找上在第一个数组里有但其他数组里没有的键，返回键以及对应的值

array_diff_uassoc()

函数用于比较两个（或更多个）数组的键名和键值 ，并返回差集

个人认为没什么用 Y_Y

array_diff_ukey()

函数用于比较两个（或更多个）数组的键名 ，并返回差集

个人认为没什么用 Y_Y

array_fill()

用值填充数组：

$a1=array_fill(3,4,"blue");
//输出
Array ( [3] => blue [4] => blue [5] => blue [6] => blue )

• array_fill(index,number,value);

• 参数 描述
  index 必需。被返回数组的第一个索引。
  number 必需。规定要插入的元素数。
  value 必需。规定供填充数组所使用的值。

array_fill_keys()

使用指定的键和值填充数组：

$keys=array("a","b","c","d");
$a1=array_fill_keys($keys,"blue");

//输出
Array ( [a] => blue [b] => blue [c] => blue [d] => blue )

array_filter()

用回调函数过滤数组中的元素：

function test_odd($a){
    return($a & 1);
}

$a1=array("a","b",2,3,4);
print_r(array_filter($a1,"test_odd"));

//输出
Array ( [3] => 3 )

• 该函数把输入数组中的每个键值传给回调函数。如果回调函数返回 true，则把输入数组中的当前键值返回结果数组中。数组键名保持不变。

• $a & 1 判断int型变量a是奇数还是偶数
  a&1 = 0 偶数
  a&1 = 1 奇数

array_flip()

反转数组中所有的键以及它们关联的值：

$a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
$result=array_flip($a1);
print_r($result);

//输出
Array ( [red] => a [green] => b [blue] => c [yellow] => d )

• array_flip() 函数用于反转/交换数组中所有的键名以及它们关联的键值。

• array_flip() 函数返回一个反转后的数组，如果同一值出现了多次，则最后一个键名将作为它的值，所有其他的键名都将丢失。

• 如果原数组中的值的数据类型不是字符串或整数，函数将报错。

array_intersect()

函数用于比较两个（或更多个）数组的键值，并返回交集。

$a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
$a2=array("e"=>"red","f"=>"black","g"=>"purple");
$a3=array("a"=>"red","b"=>"black","h"=>"yellow");

$result=array_intersect($a1,$a2,$a3);
print_r($result);

//输出
Array ( [a] => red )

• 结果数组包含了所有在被比较数组中，也同时出现在所有其他参数数组中的值，键名保留不变。

array_intersect_assoc()

函数用于比较两个（或更多个）数组的键名和键值，并返回交集。

$a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
$a2=array("a"=>"red","b"=>"green","g"=>"blue");
$a3=array("a"=>"red","b"=>"green","g"=>"blue");

$result=array_intersect_assoc($a1,$a2,$a3);
print_r($result);

//输出
Array ( [a] => red [b] => green )

• 与 array_intersect() 函数 不同的是，本函数除了比较键值，还比较键名。返回的数组中元素的键名保持不变。

array_intersect_key()

函数用于比较两个（或更多个）数组的键名 ，并返回交集。

$a1=array("a"=>"red","b"=>"green","c"=>"blue");
$a2=array("c"=>"yellow","d"=>"black","e"=>"brown");
$a3=array("f"=>"green","c"=>"purple","g"=>"red");

$result=array_intersect_key($a1,$a2,$a3);
print_r($result);

//输出
Array ( [c] => blue )

• 返回一个数组，该数组包含了所有出现在被比较的数组中并同时出现在所有其它参数数组中的键名的值。
  注释：仅有键名用于比较。

array_intersect_uassoc()

函数用于比较两个（或更多个）数组的键名和键值 ，并返回交集。
注释：该函数使用用户自定义函数比较键名！

个人认为没什么用 Y_Y

array_intersect_ukey()

函数用于比较两个（或更多个）数组的键名 ，并返回交集。
注释：该函数使用用户自定义函数比较键名！

个人认为没什么用 Y_Y

array_keys()

函数返回包含数组中所有键名的一个新数组。

$a=array(10,20,30,"10");
print_r(array_keys($a,"10",false));
//输出
Array ( [0] => 0 [1] => 3 )

$a=array(10,20,30,"10");
print_r(array_keys($a,"10",true));
//输出
Array ( [0] => 3 )

• array_keys(array,value,strict)

• 参数 描述
  array 必需。规定数组。
  value 可选。您可以指定键值，然后只有该键值对应的键名会被返回。
  strict 可选。与 value 参数一起使用。可能的值：true - 全等。false - 相等。

array_key_exists()

函数检查某个数组中是否存在指定的键名，如果键名存在则返回 true，如果键名不存在则返回 false。

$a=array("Volvo"=>"XC90","BMW"=>"X5");
if (key_exists("Toyota",$a)){
      echo "键存在！";
}else{
      echo "键不存在！";
}

array_map()

函数将用户自定义函数作用到数组中的每个值上，并返回用户自定义函数作用后的带有新值的数组。
回调函数接受的参数数目应该和传递给 array_map() 函数的数组数目一致。
提示：您可以向函数输入一个或者多个数组。

使用两个数组：

function myfunction($v1,$v2){
    if ($v1===$v2){
      return "same";
    }
    return "different";
}

$a1=array("Horse","Dog","Cat");
$a2=array("Cow","Dog","Rat");
print_r(array_map("myfunction",$a1,$a2));

//输出
Array ( [0] => different [1] => same [2] => different )

将函数名赋值为 null 时：

$a1=array("Dog","Cat");
$a2=array("Puppy","Kitten");
print_r(array_map(null,$a1,$a2));

//输出
Array ( [0] => Array ( [0] => Dog [1] => Puppy ) [1] => Array ( [0] => Cat [1] => Kitten ) )

array_merge()

函数把一个或多个数组合并为一个数组。

提示：您可以向函数输入一个或者多个数组。

$a1=array("a"=>"red","b"=>"green");
$a2=array("c"=>"blue","b"=>"yellow");
print_r(array_merge($a1,$a2));

//输出
Array ( [a] => red [b] => yellow [c] => blue )

• 如果两个或更多个数组元素有相同的键名，则最后的元素会覆盖其他元素。

• 如果您仅向 array_merge() 函数输入一个数组，且键名是整数，则该函数将返回带有整数键名的新数组，其键名以 0 开始进行重新索引

• 该函数与 array_merge_recursive() 函数之间的不同是在处理两个或更多个数组元素有相同的键名的情况。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));

//输出
Array ( [a] => red [b] => Array ( [0] => green [1] => yellow ) [c] => blue )

• 该函数与 array_merge() 函数的区别在于处理两个或更多个数组元素有相同的键名时。array_merge_recursive() 不会进行键名覆盖，而是将多个相同键名的值递归组成一个数组。

• 如果您仅仅向 array_merge_recursive() 函数输入一个数组，结果与 array_merge() 相同，函数将返回带有整数键名的新数组，其键名以 0 开始进行重新索引。

array_multisort()

函数返回排序数组。您可以输入一个或多个数组。函数先对第一个数组进行排序，接着是其他数组，如果两个或多个值相同，它将对下一个数组进行排序。

$a=array("Dog","Cat","Horse","Bear","Zebra");
array_multisort($a);
print_r($a);

//输出
Array ( [0] => Bear [1] => Cat [2] => Dog [3] => Horse [4] => Zebra )

• 字符串键名将被保留，但是数字键名将被重新索引，从 0 开始，并以 1 递增。
• 您可以在每个数组后设置排序顺序和排序类型参数。如果没有设置，每个数组参数会使用默认值。
  

  具体讲解： https://blog.csdn.net/Angus_01/article/details/80068636

array_pad()

函数将指定数量的带有指定值的元素插入到数组中

$a=array("red","green");
print_r(array_pad($a,5,"blue"));

Array ( [0] => red [1] => green [2] => blue [3] => blue [4] => blue )

$a=array("red","green");
print_r(array_pad($a,-5,"blue"));

Array ( [0] => blue [1] => blue [2] => blue [3] => red [4] => green )

array_pad(array,size,value)

• 如果您将 size 参数设置为负数，该函数会在原始数组之前插入新的元素（参见下面的实例）。
• 如果 size 参数小于原始数组的长度，该函数不会删除任何元素。

array_pop()

函数删除数组中的最后一个元素。

$a=array("red","green","blue");
array_pop($a);
print_r($a);

Array ( [0] => red [1] => green )

array_product()

函数计算并返回数组的乘积

$a=array(5,5,2,10);
echo(array_product($a));

500

array_push()

函数向第一个参数的数组尾部添加一个或多个元素（入栈），然后返回新数组的长度。

该函数等于多次调用 $array[] = $value。

$a=array("a"=>"red","b"=>"green");
array_push($a,"blue","yellow");
print_r($a);

Array ( [a] => red [b] => green [0] => blue [1] => yellow )

array_rand()

函数从数组中随机选出一个或多个元素，并返回

$a=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
print_r(array_rand($a,2));

Array ( [0] => c [1] => d )

$a=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
print_r(array_rand($a,1));

d

array_rand(array,number)

第二个参数用来确定要选出几个元素。如果选出的元素不止一个，则返回包含随机键名的数组，否则返回该元素的键名。

array_reduce()

函数向用户自定义函数发送数组中的值，并返回一个字符串。

function myfunction($v1,$v2){
    return $v1 . "-" . $v2;
}
$a=array("Dog","Cat","Horse");
print_r(array_reduce($a,"myfunction"));
print_r(array_reduce($a,"myfunction",5));

-Dog-Cat-Horse
5-Dog-Cat-Horse

• 如果指定第三个参数，则该参数将被当成是数组中的第一个值来处理，或者如果数组为空的话就作为最终返回值。

array_replace()

函数使用后面数组的值替换第一个数组的值。

$a1=array("a"=>"red","b"=>"green");
$a2=array("a"=>"orange","burgundy");
print_r(array_replace($a1,$a2));

Array ( [a] => orange [b] => green [0] => burgundy )

• 提示：您可以向函数传递一个数组，或者多个数组。

• 如果一个键存在于第一个数组 array1 同时也存在于第二个数组 array2，第一个数组 array1 中的值将被第二个数组 array2 中的值替换。如果一个键仅存在于第一个数组 array1，它将保持不变。

• 如果一个键存在于第二个数组 array2，但是不存在于第一个数组 array1，则会在第一个数组 array1 中创建这个元素。

• 如果传递了多个替换数组，它们将被按顺序依次处理，后面数组的值将覆盖之前数组的值。

array_replace_recursive()

数递归地使用后面数组的值替换第一个数组的值

$a1=array("a"=>array("red"),"b"=>array("green","blue"));
$a2=array("a"=>array("yellow"),"b"=>array("black"));
$a3=array("a"=>array("orange"),"b"=>array("burgundy"));
print_r(array_replace_recursive($a1,$a2,$a3));

Array ( [a] => Array ( [0] => orange ) [b] => Array ( [0] => burgundy [1] => blue ) )

与array_replace()区别

$a1=array("a"=>array("red"),"b"=>array("green","blue"),);
$a2=array("a"=>array("yellow"),"b"=>array("black"));

$result=array_replace_recursive($a1,$a2);
print_r($result);

$result=array_replace($a1,$a2);
print_r($result);

Array ( [a] => Array ( [0] => yellow ) [b] => Array ( [0] => black [1] => blue ) )
Array ( [a] => Array ( [0] => yellow ) [b] => Array ( [0] => black ) )

array_reverse()

函数以相反的元素顺序返回数组

$a=array("Volvo","XC90",array("BMW","Toyota"));
$reverse=array_reverse($a);
$preserve=array_reverse($a,true);

print_r($a);
print_r($reverse);
print_r($preserve);

Array ( [0] => Volvo [1] => XC90 [2] => Array ( [0] => BMW [1] => Toyota ) )
Array ( [0] => Array ( [0] => BMW [1] => Toyota ) [1] => XC90 [2] => Volvo )
Array ( [2] => Array ( [0] => BMW [1] => Toyota ) [1] => XC90 [0] => Volvo )

• 如果第二个参数指定为 true，则元素的键名保持不变，否则键名将丢失。

• 关联数组默认保留原有键名

array_search()

函数在数组中搜索某个键值，并返回对应的键名。

array_search(value,array,strict)

• 如果第三个参数 strict 被指定为 true，则只有在数据类型和值都一致时才返回相应元素的键名。

array_shift()

函数删除数组中第一个元素，并返回被删除元素的值。

$a=array("a"=>"red","b"=>"green","c"=>"blue");
echo array_shift($a);
print_r ($a);

red
Array ( [b] => green [c] => blue )

• 如果键名是数字的，所有元素都会获得新的键名，从 0 开始，并以 1 递增

array_slice()

函数在数组中根据条件取出一段值，并返回

$a=array("red","green","blue","yellow","brown");
print_r(array_slice($a,1,2));

Array ( [0] => green [1] => blue )

• 如果数组有字符串键，所返回的数组将保留键名

array_slice(array,start,length,preserve)

• array 必需。规定数组。

• start 必需。数值。规定取出元素的开始位置。 0 = 第一个元素。
  如果该值设置为正数，则从前往后开始取。
  如果该值设置为负数，则从后向前取 start 绝对值。 -2 意味着从数组的倒数第二个元素开始。

• length 可选。数值。规定被返回数组的长度。
  如果该值设置为整数，则返回该数量的元素。
  如果该值设置为负数，则函数将在举例数组末端这么远的地方终止取出。
  如果该值未设置，则返回从 start 参数设置的位置开始直到数组末端的所有元素。

• preserve 可选。规定函数是保留键名还是重置键名。可能的值：
  true - 保留键名
  false - 默认。重置键名

array_splice()

函数从数组中移除选定的元素，并用新元素取代它。该函数也将返回包含被移除元素的数组

$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 )

array_splice(array,start,length,array)

• 如果函数没有移除任何元素（length=0），则将从 start 参数的位置插入被替换数组

• 注释：不保留被替换数组中的键名。

• array 必需。规定数组。

• start
  必需。数值。规定删除元素的开始位置。
  0 = 第一个元素。
  如果该值设置为正数，则从数组中该值指定的偏移量开始移除。
  如果该值设置为负数，则从数组末端倒数该值指定的偏移量开始移除。
  -2 意味着从数组的倒数第二个元素开始。
• length
  可选。数值。规定被移除的元素个数，也是被返回数组的长度。
  如果该值设置为正数，则移除该数量的元素。
  如果该值设置为负数，则移除从 start 到数组末端倒数 length 为止中间所有的元素。
  如果该值未设置，则移除从 start 参数设置的位置开始直到数组末端的所有元素。
• array
  可选。规定带有要插入原始数组中元素的数组。
  如果只有一个元素，则可以设置为字符串，不需要设置为数组。

array_sum()

函数返回数组中所有值的和。
如果所有值都是整数，则返回一个整数值。如果其中有一个或多个值是浮点数，则返回浮点数。

array_udiff()

函数用于比较两个（或更多个）数组的键，并返回差集。

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 )

• array_udiff() 函数与 array_diff() 函数 的行为不同，后者用内部函数进行比较。

array_udiff_assoc()

函数返回 array1 中存在但其它数组中都不存在的部分

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);

Array ( [b] => green [c] => blue )

• 使用内部函数进行比较

array_unique()

函数移除数组中的重复的值，并返回结果数组。

$a=array("a"=>"red","b"=>"green","c"=>"red");
print_r(array_unique($a));

Array ( [a] => red [b] => green )

先将值作为字符串排序，然后对每个值只保留第一个遇到的键名，接着忽略所有后面的键名。这并不意味着在未排序的 array 中同一个值的第一个出现的键名会被保留。

array_unshift()

函数用于向数组插入新元素。新数组的值将被插入到数组的开头。

$a=array("a"=>"red","b"=>"green");
array_unshift($a,"blue");
print_r($a);

Array ( [0] => blue [a] => red [b] => green )

• 被加上的元素作为一个整体添加，这些元素在数组中的顺序和在参数中的顺序一样。
• 该函数会返回数组中元素的个数。
• 提示：您可以插入一个或多个值。
• 注释：数值键名将从 0 开始，以 1 递增。字符串键名将保持不变。

array_values()

函数返回一个包含给定数组中所有键值的数组，但不保留键名

$a=array("Name"=>"Bill","Age"=>"60","Country"=>"USA");
print_r(array_values($a));

Array ( [0] => Bill [1] => 60 [2] => USA )

array_walk()

array_walk(array,myfunction,userdata…)

函数对数组中的每个元素应用用户自定义函数。在函数中，数组的键名和键值是参数

function myfunction($value,$key){
    echo "The key $key has the value $value<br>";
}
$a=array("a"=>"red","b"=>"green","c"=>"blue");
array_walk($a,"myfunction");

The key a has the value red
The key b has the value green
The key c has the value blue

可以引用其他参数

function myfunction($value,$key,$p){
    echo "$key $p $value<br>";
}
$a=array("a"=>"red","b"=>"green","c"=>"blue");
array_walk($a,"myfunction","has the value");

a has the value red
b has the value green
c has the value blue

更改一个数组元素的值（请注意 &$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 )

array_walk_recursive()

对数组中的每个元素应用用户自定义函数：

function myfunction($value,$key){
    echo "键 $key 的值是 $value 。<br>";
}
$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 。

arsort()

按照键值对关联数组进行降序排序

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 对字符串进行排序，不区分大小写。

asort()

按照键值对关联数组进行升序排序：

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 对字符串进行排序，不区分大小写。

krsort()

按照键名对关联数组进行降序排序：

krsort(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 对字符串进行排序，不区分大小写。

ksort()

按照键名对关联数组进行升序排序：

ksort(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 对字符串进行排序，不区分大小写。

compact()

函数创建包含变量名和它们的值的数组。

$firstname = "Bill";
$lastname = "Gates";
$age = "60";

$result = compact("firstname", "lastname", "age");

print_r($result);

Array ( [firstname] => Bill [lastname] => Gates [age] => 60 )

count()

函数返回数组中元素的数目。

count(array,mode);

• mode
  可选。规定模式。可能的值：
  0 - 默认。不对多维数组中的所有元素进行计数
  1 - 递归地计数数组中元素的数目（计算多维数组中的所有元素）

current()

函数返回数组中的当前元素的值。

• 每个数组中都有一个内部的指针指向它的”当前”元素，初始指向插入到数组中的第一个元素。
• 提示：该函数不会移动数组内部指针。要做到这一点，请使用 next() 和 prev() 函数。
  相关的方法：
  end() - 将内部指针指向数组中的最后一个元素，并输出
  next() - 将内部指针指向数组中的下一个元素，并输出
  prev() - 将内部指针指向数组中的上一个元素，并输出
  reset() - 将内部指针指向数组中的第一个元素，并输出
  each() - 返回当前元素的键名和键值，并将内部指针向前移动
  key() - 从当前内部指针位置返回元素键名

extract()

• 函数从数组中将变量导入到当前的符号表。
• 该函数使用数组键名作为变量名，使用数组键值作为变量值。针对数组中的每个元素，将在当前符号表中创建对应的一个变量。
• 第二个参数 extract_rules用于指定当某个变量已经存在，而数组中又有同名元素时，extract() 函数如何对待这样的冲突。

• 该函数返回成功导入到符号表中的变量数目。

  $a = "Original";
  $my_array = array("a" => "Cat","b" => "Dog", "c" => "Horse");
  extract($my_array);
  echo "\$a = $a; \$b = $b; \$c = $c";
  
  //输出
  $a = Cat; $b = Dog; $c = Horse
  

extract(array,extract_rules,prefix)

• extract_rules
  可选。extract() 函数将检查每个键名是否为合法的变量名，同时也检查和符号表中已存在的变量名是否冲突。对不合法和冲突的键名的处理将根据此参数决定。
  可能的值：
  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
  可选。请注意 prefix 仅在 extract_type 的值是 EXTR_PREFIX_SAME，EXTR_PREFIX_ALL，EXTR_PREFIX_INVALID 或 EXTR_PREFIX_IF_EXISTS 时需要。如果附加了前缀后的结果不是合法的变量名，将不会导入到符号表中。
  前缀和数组键名之间会自动加上一个下划线。

in_array()

函数搜索数组中是否存在指定的值。

in_array(search,array,type)

• search 必需。规定要在数组搜索的值。
• array 必需。规定要搜索的数组。
• type 可选。如果设置该参数为 true，则检查搜索的数据与数组的值的类型是否相同。