数组函数
数组排序函数
- sort() - 对数组进行升序排列
- rsort() - 对数组进行降序排列
- asort() - 根据关联数组的值，对数组进行升序排列
- ksort() - 根据关联数组的键，对数组进行升序排列
- arsort() - 根据关联数组的值，对数组进行降序排列
- krsort() - 根据关联数组的键，对数组进行降序排列
array_rand()
返回一个包含随机键名的数组
<?php
$a=array("red","green","blue","yellow","brown");
$random_keys=array_rand($a,3);
echo $a[$random_keys[0]]."<br>";
echo $a[$random_keys[1]]."<br>";
echo $a[$random_keys[2]];
// 输出
// red
// blue
// brown
?>
// array_rand() 函数返回数组中的一个随机键名，或者如果指定函数返回键名不只一个，则返回一个包含随机键名的数组。
// array_rand(array,number)
// array: 必需。规定数组。
// number: 可选。规定返回多少个随机的元素。
range()
创建一个包含从 "0" 到 "5" 之间的元素的数组
<?php
$number = range(0,5);
print_r($number);
// 输出
// Array ( [0] => 0 [1] => 1 [2] => 2 [3] => 3 [4] => 4 [5] => 5 )
?>
// range() 函数创建一个包含指定范围的元素的数组。
// 该函数返回一个包含从 low 到 high 之间的元素的数组。
// 注释：如果 low 参数大于 high 参数，则创建的数组将是从 high 到 low。
// range(low,high,step)
// low: 必需。规定数组元素的最小值。
// high: 必需。规定数组元素的最大值。
// step: 可选。规定元素之间的步进制。默认是 1。
array_chunk()
把数组分割为带有两个元素的数组块
<?php
$cars=array("Volvo","BMW","Toyota","Honda","Mercedes","Opel");
print_r(array_chunk($cars,2));
// 输出
// Array
// Array
// (
// [0] => Array
// (
// [0] => Volvo
// [1] => BMW
// )
// [1] => Array
// (
// [0] => Toyota
// [1] => Honda
// )
// [2] => Array
// (
// [0] => Mercedes
// [1] => Opel
// )
// )
?>
// 函数把一个数组分割为新的数组块。
// array_chunk(array,size,preserve_keys);
// array: 必需。规定要使用的数组。
// size: 必需。一个整数，规定每个新数组块包含多少个元素。
// preserve_key: 可选。可能的值：true - 保留原始数组中的键名。false - 默认。每个新数组块使用从零开始的索引。
array_column()
从记录集中取出 last_name 列
<?php
// 可能从数据库中返回数组
$a = array(
array(
'id' => 5698,
'first_name' => 'Peter',
'last_name' => 'Griffin',
),
array(
'id' => 4767,
'first_name' => 'Ben',
'last_name' => 'Smith',
),
array(
'id' => 3809,
'first_name' => 'Joe',
'last_name' => 'Doe',
)
);
// 输出
// Array
// (
// [0] => Griffin
// [1] => Smith
// [2] => Doe
// )
?>
// 返回输入数组中某个单一列的值。
// array_column(array,column_key,index_key);
// array: 必需。指定要使用的多维数组（记录集）。
// column_key: 必需。需要返回值的列。可以是索引数组的列的整数索引，或者是关联数组的列的字符串键值。该参数也可以是 NULL，此时将返回整个数组（配合index_key 参数来重置数组键的时候，非常管用）。
// index_key: 可选。作为返回数组的索引/键的列。
array_combine()
通过合并两个数组来创建一个新数组，其中的一个数组元素为键名，另一个数组元素为键值
<?php
$fname = array("Peter", "Ben", "Joe");
$age = array("35", "37", "43");
$c = array_combine($fname, $age);
print_r($c);
// 输出
// Array
// (
// [Peter] => 35,
// [Ben] => 37,
// [Joe] => 43
// )
?>
// array_combine() 函数通过合并两个数组来创建一个新数组，其中的一个数组元素为键名，另一个数组的元素为键值。
// array_combine(keys, values);
// keys: 必需。规定数组的键名。
// values: 必需。规定数组的键值。
array_count_values()
统计数组中所有值出现的次数
<?php
$a=array("A","Cat","Dog","A","Dog");
print_r(array_count_values($a));
// 输出
// Array ( [A] => 2 [Cat] => 1 [Dog] => 2 )
?>
// array_count_values() 函数用于统计数组中所有值出现的次数。
// array_count_values(array)
// array: 必需。规定需要统计数组中所有值出现次数的数组。
array_change_key_case()
将数组的所有的键转换为大写字母
<?php
$age=array("Peter"=>"35","Ben"=>"37","Joe"=>"43");
print_r(array_change_key_case($age,CASE_UPPER));
// 输出
// Array
// (
// [PETER] => 35
// [BEN] => 37
// [JOE] => 43
// )
?>
// 函数将数组的所有的键都转换为大写字母或小写字母。
// array_change_key_case(array,case);
// array: 必需。规定要使用的数组。
// case: 可选。可能的值：CASE_LOWER - 默认值。将数组的键转换为小写字母。 CASE_UPPER - 将数组的键转换为大写字母。
array_key_exists()
检查键名 "Volvo" 是否存在于数组中
<?php
$a=array("Volvo"=>"XC90","BMW"=>"X5");
if (array_key_exists("Volvo",$a))
{
echo "Key exists!";
}
else
{
echo "Key does not exist!";
}
// 输出
// Key exists!
?>
// array_key_exists() 函数检查某个数组中是否存在指定的键名，如果键名存在则返回 true，如果键名不存在则返回 false。
// 提示：请记住，如果您指定数组的时候省略了键名，将会生成从 0 开始并以 1 递增的整数键名。（参阅实例 2）
// array_key_exists(key,array)
// key: 必需。规定键名。
// array: 必需。规定数组。
array_key_first()
获取数组的第一个键值
<?php
$array = ['a' => 1, 'b' => 2, 'c' => 3];
$firstKey = array_key_first($array);
echo $firstKey;
// 输出
// a
?>
// array_key_first() 函数用于获取指定数组的第一个键值。
// 取得指定数组的 array 第一个键值，不会影响到原数组的内部指针。
// array_key_first ( array $array ) : mixed
// array: 要操作的数组。
array_key_last()
获取数组的最后一个键值
<?php
$array = ['a' => 1, 'b' => 2, 'c' => 3];
$lastKey = array_key_last($array);
echo $lastKey;
// 输出
// c
?>
// array_key_last() 函数获取一个数组的最后一个键值。
// 取得指定数组的 array 最后一个键值，不会影响到原数组的内部指针。
// array_key_last ( array $array ) : mixed
// array: 要操作的数组。
array_keys()
返回包含数组中所有键名的一个新数组
<?php
$a=array("Volvo"=>"XC90","BMW"=>"X5","Toyota"=>"Highlander");
print_r(array_keys($a));
// 输出
// Array ( [0] => Volvo [1] => BMW [2] => Toyota )
?>
// array_keys() 函数返回包含数组中所有键名的一个新数组。
// array_keys(array,value,strict)
// array: 必需。规定数组。
// value: 可选。您可以指定键值，然后只有该键值对应的键名会被返回。
// strict: 可选。与 value 参数一起使用。可能的值：true - 返回带有指定键值的键名。依赖类型，数字 5 与字符串 "5" 是不同的。false - 默认值。不依赖类型，数字 5 与字符串 "5" 是相同的。
array_sum()
返回数组中所有值的和(5+15+25)
<?php
$a=array(5,15,25);
echo array_sum($a);
// 输出
// 45
?>
// array_sum() 函数返回数组中所有值的和。
// array_sum(array)
// array: 必需。规定数组。
array_map()
将函数作用到数组中的每个值上，每个值都乘以本身，并返回带有新的值的数组
<?php
function myfunction($num)
{
return($num*$num);
}
$a=array(1,2,3,4,5);
print_r(array_map("myfunction",$a));
// 输出
// Array ( [0] => 1 [1] => 4 [2] => 9 [3] => 16 [4] => 25 )
?>
// array_map() 函数将用户自定义函数作用到数组中的每个值上，并返回用户自定义函数作用后的带有新的值的数组。
// 提示：您可以向函数输入一个或者多个数组。
// array_map(myfunction,array1,array2,array3...)
// myfunction: 必需。用户自定义函数的名称，或者是 null。
// array1: 必需。规定数组。
// array2: 必需。规定数组。
// array3: 必需。规定数组。
array_merge()
把两个数组合并为一个数组
<?php
$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() 函数用于把一个或多个数组合并为一个数组。
// 提示：您可以向函数输入一个或者多个数组。
// 注释：如果两个或更多个数组元素有相同的键名，则最后的元素会覆盖其他元素。
// 注释：如果您仅仅向 array_merge() 函数输入一个数组，且键名是整数，则该函数将返回带有整数键名的新数组，其键名以 0 开始进行重新索引。
// 提示：该函数与 array_merge_recursive() 函数之间的不同是在处理两个或更多个数组元素有相同的键名的情况。array_merge_recursive() 不会进行键名覆盖，而是将多个相同键名的值递归组成一个数组。
// array_merge(array1,array2,array3...)
// array1: 必需。规定数组。
// array2: 必需。规定数组。
// array3...: 必需。规定数组。
array_merge_recursive()
把两个数组合并为一个数组
<?php
$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_recursive() 函数用于把一个或多个数组合并为一个数组。
// 该函数与 array_merge() 函数之间的不同是在处理两个或更多个数组元素有相同的键名的情况。array_merge_recursive() 不会进行键名覆盖，而是将多个相同键名的值递归组成一个数组。
// 注释：如果您仅仅向 array_merge_recursive() 函数输入一个数组，结果与 array_merge() 相同，函数将返回带有整数键名的新数组，其键名以 0 开始进行重新索引。
// array_merge_recursive(array1,array2,array3...)
// array1: 必需。规定数组。
// array2: 必需。规定数组。
// array3...: 必需。规定数组。
array_multisort()
返回一个升序排列的数组
<?php
$a=array("Dog","Cat","Horse","Bear","Zebra");
array_multisort($a);
print_r($a);
// 输出
// Array ( [0] => Bear [1] => Cat [2] => Dog [3] => Horse [4] => Zebra )
?>
// array_multisort() 函数返回一个排序数组。您可以输入一个或多个数组。函数先对第一个数组进行排序，接着是其他数组，如果两个或多个值相同，它将对下一个数组进行排序。
// 注释：字符串键名将被保留，但是数字键名将被重新索引，从 0 开始，并以 1 递增。
// 注释：您可以在每个数组后设置排序顺序和排序类型参数。如果没有设置，每个数组参数会使用默认值。
// array_multisort(array1,sorting order,sorting type,array2,array3...)
// array1: 必需。规定数组。
// sorting order: 可选。规定排列顺序。可能的值：
// SORT_ASC - 默认。按升序排列 (A-Z)。
// SORT_DESC - 按降序排列 (Z-A)。
// sorting type: 可选。规定排序类型。可能的值：
// SORT_REGULAR - 默认。把每一项按常规顺序排列（Standard ASCII，不改变类型）。
// SORT_NUMERIC - 把每一项作为数字来处理。
// SORT_STRING - 把每一项作为字符串来处理。
// SORT_LOCALE_STRING - 把每一项作为字符串来处理，基于当前区域设置（可通过 setlocale() 进行更改）。
// SORT_NATURAL - 把每一项作为字符串来处理，使用类似 natsort() 的自然排序。
// SORT_FLAG_CASE - 可以结合（按位或）SORT_STRING 或 SORT_NATURAL 对字符串进行排序，不区分大小写。
// array2: 可选。规定数组。
// array3: 可选。规定数组。
array_search()
在数组中搜索键值 "red"，并返回它的键名
<?php
$a=array("a"=>"red","b"=>"green","c"=>"blue");
echo array_search("red",$a);
// 输出
// a
?>
// array_search() 函数在数组中搜索某个键值，并返回对应的键名。
// array_search(value,array,strict)
// value: 必需。规定在数组中搜索的键值。
// array: 必需。规定被搜索的数组。
// strict: 可选。如果该参数被设置为 TRUE，则函数在数组中搜索数据类型和值都一致的元素。可能的值：
// true
// false - 默认
// 如果设置为 true，则在数组中检查给定值的类型，数字 5 和字符串 5 是不同的。
array_shift()
删除数组中的第一个元素（red），并返回被删除的元素
<?php
$a=array("a"=>"red","b"=>"green","c"=>"blue");
echo array_shift($a)."<br>";
print_r($a);
// 输出
// red
// Array ( [b] => green [c] => blue )
?>
// array_shift() 函数用于删除数组中的第一个元素，并返回被删除的元素。
// 注释：如果键名是数字的，所有元素都将获得新的键名，从 0 开始，并以 1 递增（参见下面实例）。
// array_shift(array)
// array: 必需。规定数组。
array_slice()
从数组的第三个元素（索引为 2）开始取出，并返回直到数组末端的所有元素
<?php
$a=array("red","green","blue","yellow","brown");
print_r(array_slice($a,2));
// 输出
// Array ( [0] => blue [1] => yellow [2] => brown )
?>
// array_slice() 函数返回数组中的选定部分。
// 注释：如果数组有字符串键名，所返回的数组将保留键名
// array_slice(array,start,length,preserve)
// array: 必需。规定数组。
// start: 必需。数值。规定取出元素的开始位置。 0 = 第一个元素。 如果该值设置为正数，则从前往后开始取。如果该值设置为负数，则从后向前取 start 绝对值。 -2 意味着从数组的倒数第二个元素开始。
// length: 可选。数值。规定被返回数组的长度。 如果该值设置为整数，则返回该数量的元素。如果该值设置为负数，则函数将在举例数组末端这么远的地方终止取出。如果该值未设置，则返回从 start 参数设置的位置开始直到数组末端的所有元素。
// preserve: 可选。规定函数是保留键名还是重置键名。可能的值：
// true - 保留键名
// false - 默认。重置键名
array_splice()
从数组中移除元素，并用新元素取代它
<?php
$a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
$a2=array("a"=>"purple","b"=>"orange");
array_splice($a1,0,2,$a2);
print_r($a1);
// 输出
// Array ( [0] => purple [1] => orange [c] => blue [d] => yellow )
?>
// array_splice() 函数从数组中移除选定的元素，并用新元素取代它。函数也将返回被移除元素的数组。
// 提示：如果函数没有移除任何元素（length=0），则替代数组将从 start 参数的位置插入（参见实例 2）。
// 注释：不保留替代数组中的键名。
// array_splice(array1,start,length,array2)
// array1: 必需。规定数组。
// start: 必需。数值。规定删除元素的开始位置。 0 = 第一个元素。 如果该值设置为正数，则从数组中该值指定的偏移量开始移除。如果该值设置为负数，则从数组末端倒数该值指定的偏移量开始移除。 -2 意味着从数组的倒数第二个元素开始。
// length: 可选。数值。规定被移除的元素个数，也是被返回数组的长度。 如果该值设置为正数，则移除该数量的元素。如果该值设置为负数，则移除从 start 到数组末端倒数 length 为止中间所有的元素。如果该值未设置，则移除从 start 参数设置的位置开始直到数组末端的所有元素。
// array2: 可选。规定带有要插入原始数组中元素的数组。如果只有一个元素，则可以设置为字符串，不需要设置为数组。
array_diff()
比较数组，返回两个数组的差集（只比较键值）
<?php
$a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
$a2=array("e"=>"red","f"=>"green","g"=>"blue");
$result=array_diff($a1,$a2);
print_r($result);
// 输出
// Array ( [d] => yellow )
?>
// array_diff() 函数用于比较两个（或更多个）数组的值，并返回差集。
// 该函数比较两个（或更多个）数组的值（key=>value 中的 value），并返回一个差集数组，该数组包括了所有在被比较的数组（array1）中，但是不在任何其他参数数组（array2 或 array3 等等）中的值。
// array_diff(array1,array2,array3...);
// array1: 必需。与其他数组进行比较的第一个数组。
// array2: 必需。与第一个数组进行比较的数组。
// array3...: 可选。与第一个数组进行比较的其他数组。
用这个来比较几个数组是否相同时要注意了
array_diff($array1, $array2); 不管这两个数组是否相同都有可能返回的是空数组，因为它只返回 $array1 的差集，所以要验证是否相同的要相互比较才行，就像这样：
array_diff_assoc()
比较数组，返回两个数组的差集（比较键名和键值）
<?php
$a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
$a2=array("a"=>"red","b"=>"green","c"=>"blue");
$result=array_diff_assoc($a1,$a2);
print_r($result);
// 输出
// Array ( [d] => yellow )
?>
// array_diff_assoc() 函数用于比较两个（或更多个）数组的键名和键值 ，并返回差集。
// 该函数比较两个（或更多个）数组的键名和键值，并返回一个差集数组，该数组包括了所有在被比较的数组（array1）中，但是不在任何其他参数数组（array2 或 array3 等等）中的键名和键值。
// array_diff_assoc(array1,array2,array3...);
// array1: 必需。与其他数组进行比较的第一个数组。
// array2: 必需。与第一个数组进行比较的数组。
// array3...: 可选。与第一个数组进行比较的其他数组。
array_diff_key()
比较两个数组的键名，并返回差集
<?php
$a1=array("a"=>"red","b"=>"green","c"=>"blue");
$a2=array("a"=>"red","c"=>"blue","d"=>"pink");
$result=array_diff_key($a1,$a2);
print_r($result);
// 输出
// Array ( [b] => green )
?>
// array_diff_key() 函数用于比较两个（或更多个）数组的键名 ，并返回差集。
// 该函数比较两个（或更多个）数组的键名，并返回一个差集数组，该数组包括了所有在被比较的数组（array1）中，但是不在任何其他参数数组（array2 或 array3 等等）中的键名。
// array_diff_key(array1,array2,array3...);
// array1: 必需。与其他数组进行比较的第一个数组。
// array2: 必需。与第一个数组进行比较的数组。
// array3...: 可选。与第一个数组进行比较的其他数组。
array_diff_uassoc()
比较两个数组的键名和键值（使用用户自定义函数比较键名），并返回差集
<?php
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);
// 输出
// Array ( [a] => red [c] => blue )
?>
// array_diff_uassoc() 函数用于比较两个（或更多个）数组的键名和键值 ，并返回差集。
// 注释：该函数使用用户自定义函数比较键名！
// 该函数比较两个（或更多个）数组的键名和键值，并返回一个差集数组，该数组包括了所有在被比较的数组（array1）中，但是不在任何其他参数数组（array2 或 array3 等等）中的键名和键值。
// array_diff_uassoc(array1,array2,array3...,myfunction);
// array1: 必需。与其他数组进行比较的第一个数组。
// array2: 必需。与第一个数组进行比较的数组。
// array3...: 可选。与第一个数组进行比较的其他数组。
// myfunction: 必需。一个定义了可调用比较函数的字符串。如果第一个参数 <, =, > 第二个参数，相应地比较函数必须返回一个 <, =, > 0 的整数。
array_diff_ukey()
比较两个数组的键名（使用用户自定义函数比较键名），并返回差集
<?php
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);
// 输出
// Array ( [c] => blue )
?>
// array_diff_ukey() 函数用于比较两个（或更多个）数组的键名 ，并返回差集。
// 注释：该函数使用用户自定义函数比较键名！
// 该函数比较两个（或更多个）数组的键名，并返回一个差集数组，该数组包括了所有在被比较的数组（array1）中，但是不在任何其他参数数组（array2 或 array3 等等）中的键名。
// array_diff_ukey(array1,array2,array3...,myfunction);
// array1: 必需。与其他数组进行比较的第一个数组。
// array2: 必需。与第一个数组进行比较的数组。
// array3...: 可选。与第一个数组进行比较的其他数组
// myfunction: 必需。一个定义了可调用比较函数的字符串。如果第一个参数 <, =, > 第二个参数，相应地比较函数必须返回一个 <, =, > 0 的整数。
array_fill()
用给定的键值填充数组
<?php
$a1=array_fill(3,4,"blue");
$b1=array_fill(0,1,"red");
print_r($a1);
echo "<br>";
print_r($b1);
// 输出
// Array ( [3] => blue [4] => blue [5] => blue [6] => blue )
// Array ( [0] => red )
?>
// array_fill() 函数用给定的键值填充数组。
// array_fill(index,number,value);
// index: 必需。规定返回数组的起始索引。
// number: 必需。规定填充的元素的数量，其值必须大于 0。
// value: 必需。规定用于填充数组的键值。
array_fill_keys()
用给定的指定键名的键值填充数组
<?php
$keys=array("a","b","c","d");
$a1=array_fill_keys($keys,"blue");
print_r($a1);
// 输出
// Array ( [a] => blue [b] => blue [c] => blue [d] => blue )
?>
// array_fill_keys() 函数用给定的指定键名的键值填充数组。
// array_fill_keys(keys,value);
// keys: 必需。数组，其值将被用于填充数组的键名。
// value: 必需。规定用于填充数组的键值。
array_filter()
用回调函数过滤数组中的元素
<?php
function test_odd($var)
{
return($var & 1);
}
$a1=array("a","b",2,3,4);
print_r(array_filter($a1,"test_odd"));
// 输出
// Array ( [3] => 3 )
?>
// array_filter() 函数用回调函数过滤数组中的元素。
// 该函数把输入数组中的每个键值传给回调函数。如果回调函数返回 true，则把输入数组中的当前键值返回给结果数组。数组键名保持不变。
// array array_filter ( array $array [, callable $callback [, int $flag = 0 ]] )
// array: 必需。规定要过滤的数组。
// callback: 可选。规定要用的回调函数。
// flag: 可选。决定 callback
// 接收的参数形式:
// ARRAY_FILTER_USE_KEY - callback 接受键名作为的唯一参数。
// ARRAY_FILTER_USE_BOTH - callback 同时接受键名和键值
array_flip()
反转数组中的键名和对应关联的键值
<?php
$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);
// array: 必需。规定需进行键/值对反转的数组。
array_intersect()
比较两个数组的值，并返回交集
<?php
$a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
$a2=array("e"=>"red","f"=>"green","g"=>"blue");
$result=array_intersect($a1,$a2);
print_r($result);
// 输出
// Array ( [a] => red [b] => green [c] => blue )
?>
// array_intersect() 函数用于比较两个（或更多个）数组的值，并返回交集。
// 该函数比较两个（或更多个）数组的值，并返回一个交集数组，该数组包含了所有在 array1 中也同时出现在所有其它参数数组中的值。
// array_intersect(array1,array2,array3...);
// array1: 必需。与其他数组进行比较的第一个数组。
// array2: 必需。与第一个数组进行比较的数组。
// array3...: 可选。与第一个数组进行比较的其他数组。
array_intersect_assoc()
比较两个数组的键名和键值，并返回交集
<?php
$a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
$a2=array("a"=>"red","b"=>"green","c"=>"blue");
$result=array_intersect_assoc($a1,$a2);
print_r($result);
// 输出
// Array ( [a] => red [b] => green [c] => blue )
?>
// array_intersect_assoc() 函数用于比较两个（或更多个）数组的键名和键值，并返回交集。
// 该函数比较两个（或更多个）数组的键名和键值，并返回一个交集数组，该数组包括了所有在被比较的数组（array1）中，同时也在任何其他参数数组（array2 或 array3 等等）中的键名和键值。
// array_intersect_assoc(array1,array2,array3...)
// array1: 必需。与其他数组进行比较的第一个数组。
// array2: 必需。与第一个数组进行比较的数组。
// array3...: 可选。与第一个数组进行比较的其他数组。
array_intersect_key()
比较两个数组的键名，并返回交集
<?php
$a1=array("a"=>"red","b"=>"green","c"=>"blue");
$a2=array("a"=>"red","c"=>"blue","d"=>"pink");
$result=array_intersect_key($a1,$a2);
print_r($result);
// 输出
// Array ( [a] => red [c] => blue )
?>
// array_intersect_key() 函数用于比较两个（或更多个）数组的键名 ，并返回交集。
// 该函数比较两个（或更多个）数组的键名，并返回一个交集数组，该数组包括了所有在被比较的数组（array1）中，同时也在任何其他参数数组（array2 或 array3 等等）中的键名。
// array_intersect_key(array1,array2,array3...)
// array1: 必需。与其他数组进行比较的第一个数组。
// array2: 必需。与第一个数组进行比较的数组。
// array3...: 可选。与第一个数组进行比较的其他数组。
array_intersect_uassoc()
比较两个数组的键名和键值（使用用户自定义函数比较键名），并返回交集
<?php
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);
// 输出
// Array ( [b] => green )
?>
// array_intersect_uassoc() 函数用于比较两个（或更多个）数组的键名和键值 ，并返回交集。
// 注释：该函数使用用户自定义函数比较键名！
// 该函数比较两个（或更多个）数组的键名和键值，并返回一个交集数组，该数组包括了所有在被比较的数组（array1）中，同时也在任何其他参数数组（array2 或 array3 等等）中的键名和键值。
// array_intersect_uassoc(array1,array2,array3...,myfunction)
// array1: 必需。与其他数组进行比较的第一个数组。
// array2: 必需。与第一个数组进行比较的数组。
// array3...: 可选。与第一个数组进行比较的其他数组。
// myfunction: 必需。一个定义了可调用比较函数的字符串。如果第一个参数 <, =, > 第二个参数，相应地比较函数必须返回一个 <, =, > 0 的整数。
array_intersect_ukey()
比较两个数组的键名（使用用户自定义函数比较键名），并返回交集
<?php
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);
// 输出
// Array ( [a] => red [b] => green )
?>
// array_intersect_ukey() 函数用于比较两个（或更多个）数组的键名 ，并返回交集。
// 注释：该函数使用用户自定义函数比较键名！
// 该函数比较两个（或更多个）数组的键名，并返回一个交集数组，该数组包括了所有在被比较的数组（array1）中，同时也在任何其他参数数组（array2 或 array3 等等）中的键名。
// array_intersect_ukey(array1,array2,array3...,myfunction)
// array1: 必需。与其他数组进行比较的第一个数组。
// array2: 必需。与第一个数组进行比较的数组。
// array3...: 可选。与第一个数组进行比较的其他数组。
// myfunction: 必需。一个定义了可调用比较函数的字符串。如果第一个参数 <, =, > 第二个参数，相应地比较函数必须返回一个 <, =, > 0 的整数。
array_pad()
返回 5 个元素，并将 "blue" 值插入到数组的新元素中
<?php
$a=array("red","green");
print_r(array_pad($a,5,"blue"));
// 输出
// Array ( [0] => red [1] => green [2] => blue [3] => blue [4] => blue )
?>
// array_pad() 函数将指定数量的带有指定值的元素插入到数组中。
// 提示：如果您将 size 参数设置为负数，该函数会在原始数组之前插入新的元素（参见下面的实例）。
// 注释：如果 size 参数小于原始数组的长度，该函数不会删除任何元素。
// array_pad(array,size,value)
// array: 必需。规定数组。
// size: 必需。规定从函数返回的数组元素个数。
// value: 必需。规定从函数返回的数组中新元素的值。
array_pop()
删除数组中的最后一个元素
<?php
$a=array("red","green","blue");
array_pop($a);
print_r($a);
// 输出
// Array ( [0] => red [1] => green )
?>
// array_pop() 函数删除数组中的最后一个元素。
// array_pop(array)
// array: 必需。规定数组。
array_product()
计算并返回数组的乘积
<?php
$a=array(5,5);
echo(array_product($a));
// 输出
// 25
?>
// array_product() 函数计算并返回数组的乘积。
// array_product(array)
// array: 必需。规定数组。
array_push()
向数组尾部插入 "blue" 和 "yellow"
<?php
$a=array("red","green");
array_push($a,"blue","yellow");
print_r($a);
// 输出
// Array ( [0] => red [1] => green [2] => blue [3] => yellow )
?>
// array_push() 函数向数组尾部插入一个或多个元素。
// 提示：您可以添加一个或者多个值。
// 注释：即使您的数组有字符串键名，您所添加的元素将是数字键名（参见下面的实例）。
// array_push(array,value1,value2...)
// array: 必需。规定一个数组。
// value1: 必需。规定要添加的值。
// value2...: 可选。规定要添加的值。
array_reduce()
发送数组中的值到用户自定义函数，并返回一个字符串
<?php
function myfunction($v1,$v2)
{
return $v1 . "-" . $v2;
}
$a=array("Dog","Cat","Horse");
print_r(array_reduce($a,"myfunction"));
// 输出
// -Dog-Cat-Horse
?>
// array_reduce() 函数发送数组中的值到用户自定义函数，并返回一个字符串。
// 注释：如果数组是空的或者初始值未传递，该函数返回 NULL。
// array_reduce(array,myfunction,initial)
// array: 必需。规定数组。
// myfunction: 必需。规定函数的名称。
// initial: 可选。规定发送到函数处理的第一个值。
array_replace()
使用第二个数组（\(a2）的值替换第一个数组（\)a1）的值
<?php
$a1=array("red","green");
$a2=array("blue","yellow");
print_r(array_replace($a1,$a2));
// 输出
// Array ( [0] => blue [1] => yellow )
?>
// array_replace() 函数使用后面数组的值替换第一个数组的值。
// 提示：您可以向函数传递一个数组，或者多个数组。
// 如果一个键存在于第一个数组 array1 同时也存在于第二个数组 array2，第一个数组 array1 中的值将被第二个数组 array2 中的值替换。如果一个键仅存在于第一个数组 array1，它将保持不变。（详见下面的实例 1）
// 如果一个键存在于第二个数组 array2，但是不存在于第一个数组 array1，则会在第一个数组 array1 中创建这个元素。
// 如果传递了多个替换数组，它们将被按顺序依次处理，后面数组的值将覆盖之前数组的值。（详见下面的实例 3）
// 提示：请使用 array_replace_recursive() 来递归地使用后面数组的值替换第一个数组的值。
// array_replace(array1,array2,array3...)
// array1: 必需。指定一个数组。
// value2: 可选。指定一个要替换 array1 的值的数组。
// value3...: 可选。指定多个要替换 array1 和 array2, ... 的值的数组。后面数组的值将覆盖之前数组的值。
array_replace_recursive()
递归地使用第二个数组（\(a2）的值替换第一个数组（\)a1）的值
<?php
$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 ( [a] => Array ( [0] => yellow ) [b] => Array ( [0] => black [1] => blue ) )
?>
// array_replace_recursive() 函数递归地使用后面数组的值替换第一个数组的值。
// 提示：您可以向函数传递一个数组，或者多个数组。
// 如果一个键存在于第一个数组 array1 同时也存在于第二个数组 array2，第一个数组 array1 中的值将被第二个数组 array2 中的值替换。如果一个键仅存在于第一个数组 array1，它将保持不变。如果一个键存在于第二个数组 array2，但是不存在于第一个数组 array1，则会在第一个数组 array1 中创建这个元素。如果传递了多个替换数组，它们将被按顺序依次处理，后面数组的值将覆盖之前数组的值。
// 注释：如果没有为每个数组指定一个键，该函数的行为将等同于 array_replace() 函数。
// array_replace_recursive(array1,array2,array3...)
// array1: 必需。指定一个数组。
// array2: 可选。指定一个要替换 array1 的值的数组。
// array3...: 可选。指定多个要替换 array1 和 array2, ... 的值的数组。后面数组的值将覆盖之前数组的值。
array_reverse()
返回翻转顺序的数组
<?php
$a=array("a"=>"Volvo","b"=>"BMW","c"=>"Toyota");
print_r(array_reverse($a));
// 输出
// Array ( [c] => Toyota [b] => BMW [a] => Volvo )
?>
// array_reverse() 函数返回翻转顺序的数组。
// array_reverse(array,preserve)
// array: 必需。规定一个数组。
// preserve: 可选。规定是否保留原始数组的键名。
// 如果设置为 TRUE 会保留数字的键。 非数字的键则不受这个设置的影响，总是会被保留。
// 可能的值：
// true
// false