PHP有74个和数组处理相关的函数，先给出一个总表：
array_change_key_case — 转变数组中所有键值的大小写形式
array_chunk — 将一个数组拆成多个小单元
array_combine — 用一个数组的值作为其键名，另一个数组的值作为其值的方法来创建数组
array_count_values — 统计数组中的值出现的次数
array_diff_assoc — 根据值和键值计算若干个数组相对于第一个数组参数的差集
array_diff_key — 根据键值计算若干个数组相对于第一个数组参数的差集
array_diff_uassoc –根据值和键值计算若干个数组相对于第一个数组参数的差集，可使用回调函数对键值进行比较
array_diff_ukey — 根据键值计算若干个数组相对于第一个数组参数的差集，可使用回调函数比较键名
array_diff — 根据值来计算若干个数组相对于第一个数组参数的差集
array_fill — 用给定的值填充数组
array_filter — 使用回调函数对数组进行过滤操作
array_flip — 交换数组中的键和值
array_intersect_assoc — 根据值和键值来计算数组的交集
array_intersect_key — 根据键值比较计算数组的交集
array_intersect_uassoc — 根据值和键值来计算数组的交集，可使用回调函数对键值进行比较
array_intersect_ukey — 根据键值比较计算数组的交集，可使用回调函数比较键名
array_intersect — 根据值来计算数组的交集
array_key_exists — 检查给定的键名是否存在于数组中
array_keys — 返回数组中所有的键名
array_map — 对数组中的每个元素应用回调函数后返回结果
array_merge_recursive — 用来处理多维数组的合并
array_merge — 重排单个数组的键值或者合并两个数组
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_assoc — 根据值和键值来计算数组的交集，可使用回调函数比较值
array_udiff_uassoc — 根据值和键值来计算数组的交集，可使用回调函数比较值
array_udiff — 根据值来计算若干个数组相对于第一个数组参数的差集，可使用回调函数比较值
array_uintersect_assoc — 根据值和键值来计算数组的交集，可使用回调函数对值进行比较
array_uintersect_uassoc — 根据值和键值来计算数组的交集，可使用回调函数对值和键值进行比较
array_uintersect — 根据值来计算数组的交集，可使用回调函数比较值
array_unique — 移除数组中重复的值
array_unshift — 将传入的单元插入到数组的开头
array_values — 返回数组中所有的值
array_walk_recursive — 对数组中的每个元素递归的应用一个回调函数
array_walk — 对数组中的每个元素应用一个回调函数
array — 新建一个数组
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()函数的作用是创建一个数组。如果省略了索引，会自动产生从 0 开始的整数索引。如果索引是整数，则下一个产生的索引将是目前最大的整数索引 + 1。注意如果定义了两个完全一样的索引，则后面一个会覆盖前一个。array()函数的最后一项后面可以添加一个“,”，但不起任何作用。
<?php
$array
=
array
(
1
,
1
,
1
,
1
,
1
,
8
=>
1
,
4
=>
1
,
19
,
3
=>
13
,
)
;
print_r
(
$array
)
;
/* 显示
Array
(
[0] => 1
[1] => 1
[2] => 1
[3] => 13
[4] => 1
[8] => 1
[9] => 19
)
*/
?>
range()函数的作用是建立一个包含指定范围单元的数组，range()函数的第一个参数表示开始单元的值，第二个参数表示最后一个单元的值， 第三个参数表示值的跨度，第三个参数的默认值为1。第一第二个参数如果输入了字符串，将会截取第一个字母，建立字母为值的数组。
<?php
$number
=
range
(
100
,
0
,
20
)
;
print_r
(
$number
)
;
/* 显示
Array
(
[0] => 100
[1] => 80
[2] => 60
[3] => 40
[4] => 20
[5] => 0
)
*/
$number
=
range
(
"
g
"
,
"
a
"
,
2
)
;
print_r
(
$number
)
;
/* 显示
Array
(
[0] => g
[1] => e
[2] => c
[3] => a
)
*/
?>
compact()函数可以将变量转变为数组，$key为变量的名称，$value为变量的值。compact()函数的操作可以通过数组递归地完成。
<?php
$name
=
"
Bom
"
;
$result
=
compact
(
"
name
"
)
;
print_r
(
$result
)
;
// 显示 Array ( [name] => Bom )
$name
=
"
Bom
"
;
$age
=
25
;
$city
=
"
shanghai
"
;
$result
=
compact
(
array
(
"
name
"
,
"
age
"
,
"
city
"
))
;
print_r
(
$result
)
;
/* 显示
Array
(
[name] => Bom
[age] => 25
[city] => shanghai
)
*/
?>
extract()函数的作用是将一个数组的键值作为变量名，将数组的值作为变量的值进行批量赋值，extract()函数的第二个参数有8个常量 参数可以选择：EXTR_OVERWRITE：如果有冲突，覆盖已有的变量；EXTR_SKIP：如果有冲突，不覆盖已有的变量； EXTR_PREFIX_SAME：如果有冲突，在变量名前加上第三个参数作为前缀；EXTR_PREFIX_ALL：给所有变量名前加上第三个参数作为 前缀；EXTR_PREFIX_INVALID：仅在非法／数字的变量名前加上第三个参数作为前缀；EXTR_IF_EXISTS：仅在当前已有同名变量 时，覆盖它们的值；EXTR_PREFIX_IF_EXISTS：仅在当前已有同名变量时，建立第三个参数作为前缀；EXTR_REFS：将变量作为引用 提取。这有力地表明了导入的变量仍然引用了 var_array 参数的值。可以单独使用这个标志或者在 extract_type 中用 OR 与其它任何标志结合使用。在需要的情况下，会使用第三个参数作为新变量名的前缀。
<?php
$size
=
"
large
"
;
$var_array
=
array
(
"
color
"
=>
"
blue
"
,
"
size
"
=>
"
medium
"
,
"
shape
"
=>
"
sphere
"
)
;
extract
(
$var_array
,
EXTR_PREFIX_SAME
,
"
wddx
"
)
;
echo
"
$color
,
$size
,
$shape
,
$wddx_size
"
;
// 显示 blue, large, sphere, medium
?>
array_combine()函数的作用是用一个数组的值作为其键名，另一个数组的值作为其值的方法来创建数组。
<?php
$a
=
array
(
'
green
'
,
'
red
'
,
'
yellow
'
)
;
$b
=
array
(
'
avocado
'
,
'
apple
'
,
'
banana
'
)
;
$c
=
array_combine
(
$a
,
$b
)
;
print_r
(
$c
)
;
/* 显示
Array
(
[green] => avocado
[red] => apple
[yellow] => banana
)
*/
?>
array_merge()函数的作用是重排单个数组的键值或者合并两个数组。如果只给了一个数组并且该数组是数字索引的，则键名会以连续方式重新 索引，字符键值不会受影响。如果有两个以上的参数，则进行数组合并的操作，如果数组中有相同的字符串键名，则该键名后面的值将覆盖前一个值，如果是相同的 数字键名，后面的值将会附加到原来的值后面。
<?php
$a
=
array
(
4
=>
'
green
'
,
6
=>
'
red
'
,
'
fruit
'
=>
'
yellow
'
)
;
$a
=
array_merge
(
$a
)
;
print_r
(
$a
)
/* 显示
Array
(
[0] => green
[1] => red
[fruit] => yellow
)
*/
$a
=
array
(
4
=>
'
green
'
,
6
=>
'
red
'
,
'
fruit
'
=>
'
yellow
'
)
;
$b
=
array
(
4
=>
'
greens
'
,
6
=>
'
reds
'
,
'
fruit
'
=>
'
yellows
'
)
;
$a
=
array_merge
(
$a
,
$b
)
;
print_r
(
$a
)
/* 显示
Array
(
[0] => green
[1] => red
[fruit] => yellows
[2] => greens
[3] => reds
)
*/
?>
array_merge_recursive()函数的处理方式和array_merge()函数类似，但是array_merge_recursive()函数可以用来处理多维数组的合并。
<?php
$ar1
=
array
(
"
color
"
=>
array
(
"
favorite
"
=>
"
red
"
)
,
5
)
;
$ar2
=
array
(
10
,
"
color
"
=>
array
(
"
favorite
"
=>
"
green
"
,
"
blue
"
))
;
$result
=
array_merge_recursive
(
$ar1
,
$ar2
)
;
print_r
(
$result
)
;
/* 显示
Array
(
[color] => Array
(
[favorite] => Array
(
[0] => red
[1] => green
)
[0] => blue
)
[0] => 5
[1] => 10
)
*/
?>
count()函数的作用是计算数组的个数。count()函数的第二个参数如果被设置为常量COUNT_RECURSIVE，将会递归地去计算数组的个数。sizeof()函数的作用和count()函数的作用完全相同
<?php
$food
=
array
(
'
fruits
'
=>
array
(
'
orange
'
,
'
banana
'
,
'
apple
'
)
,
'
veggie
'
=>
array
(
'
carrot
'
,
'
collard
'
,
'
pea
'
)
)
;
echo
count
(
$food
,
COUNT_RECURSIVE
)
;
// 显示 8
echo
count
(
$food
)
;
// 显示 2
?>
array_count_values()函数的作用统计数组中的值出现的次数。
<?php
$array
=
array
(
1
,
"
hello
"
,
1
,
"
world
"
,
"
hello
"
)
;
print_r
(
array_count_values
(
$array
))
;
/* 显示
Array
(
[1] => 2
[hello] => 2
[world] => 1
)
*/
?>
array_values()函数的作用是返回所有元素的值。
<?php
$array
=
array
(
"
size
"
=>
"
XL
"
,
"
color
"
=>
"
gold
"
)
;
print_r
(
array_values
(
$array
))
;
/* 显示
Array
(
[0] => XL
[1] => gold
)
*/
?>
array_keys()函数的作用是返回数组的键名，如果设置了第二个参数，则可以返回指定值的单元的键值，第三个参数设置为true是，可以让第二个参数进行“===”的比较。
<?php
$array
=
array
(
"
blue
"
,
"
red
"
,
"
green
"
,
"
blue
"
,
"
blue
"
)
;
print_r
(
array_keys
(
$array
,
"
blue
"
))
;
/* 显示
Array
(
[0] => 0
[1] => 3
[2] => 4
)
*/
?>
array_key_exists()函数的作用是检查给定的键名是否存在于数组中。
<?php
$
array
=
array
(
'
first
'
=>
1
,
'
second
'
=>
4
)
;
echo
array_key_exists
(
'
first
'
, $
array
)
;
// 显示 1
?>
下面这个例子说明array_key_exists()函数和isset()函数在检测时候的微小区别，就是在对null的处理上。
<?php
$search_array
=
array
(
'
first
'
=>
null
,
'
second
'
=>
4
)
;
isset
(
$search_array
[
'
first
'
])
;
// 返回false
array_key_exists
(
'
first
'
,
$search_array
)
;
// 返回true
?>
in_array()函数的作用是检查数组中是否存在某个值，比较同时检查键值和值。比较是区分大小写的。第三个参数设置为true时，匹配将会通过“===”来进行。
<?php
$a
=
array
(
'
o
'
,
array
(
'
c
'
=>
'
p
'
,
'
h
'
)
,
array
(
'
p
'
,
'
r
'
))
;
echo
in_array
(
array
(
'
c
'
=>
'
p
'
,
'
h
'
)
,
$a
)
;
// 返回true
in_array
(
array
(
'
f
'
,
'
i
'
)
,
$a
)
;
// 返回false
in_array
(
'
o
'
,
$a
)
;
// 返回true
?>
array_sum()函数的作用是得出数组所有单元值的和，字符串单元会被自动转换成0。
<?php
$b
=
array
(
"
a
"
=>
1.2
,
"
b
"
=>
2.3
,
"
c
"
=>
3.4
,
"
d
"
=>
"
string
"
)
;
echo
array_sum
(
$b
)
;
//显示 6.9
?>
array_product()函数的作用是得出数组所有单元值的乘积，字符串单元会被自动转换成0。
<?php
$a
=
array
(
2
,
4
,
6
,
8
)
;
echo
array_product
(
$a
)
;
//显示 384
?>
array_shift()函数的作用是将数组的第一个单元移出并作为结果返回，将数组的长度减一并将所有其它单元向前移动一位。所有的数字键名将改为从零开始计数，文字键名将不变。
<?php
$stack
=
array
(
7
=>
"
orange
"
,
8
=>
"
banana
"
,
9
=>
"
apple
"
)
;
$fruit
=
array_shift
(
$stack
)
;
print_r
(
$stack
)
;
/* 显示
Array
(
[0] => banana
[1] => apple
)
*/
echo
$fruit
;
// 显示 orange
?>
array_unshift()函数的作用是将传入的单元插入到数组的开头。注意单元是作为整体被插入的，因此传入单元将保持同样的顺序。所有的数值键名将修改为从零开始重新计数，所有的文字键名保持不变。
<?php
$queue
=
array
(
"
orange
"
,
"
banana
"
)
;
array_unshift
(
$queue
,
"
apple
"
,
"
raspberry
"
)
;
print_r
(
$queue
)
;
/* 显示
Array
(
[0] => apple
[1] => raspberry
[2] => orange
[3] => banana
)
*/
?>
array_pop()函数的作用是将数组的最后一个单元弹出，并返回被弹出数组元素的值。
<?php
$queue
=
array
(
7
=>
"
orange
"
,
8
=>
"
banana
"
,
9
=>
"
apple
"
)
;
$fruit
=
array_pop
(
$queue
)
;
print_r
(
$queue
)
;
/* 显示
Array
(
[7] => orange
[8] => banana
)
*/
echo
$fruit
;
// 显示 apple
?>
array_push()函数的作用是将一个或多个单元添加到数组的末尾，并返回数组新的单元总数
<?php
$stack
=
array
(
"
orange
"
,
"
banana
"
)
;
$fruit
=
array_push
(
$stack
,
"
apple
"
,
"
raspberry
"
)
;
print_r
(
$stack
)
;
/* 显示
Array
(
[0] => orange
[1] => banana
[2] => apple
[3] => raspberry
)
*/
echo
$fruit
;
// 显示 4
?>
array_slice()函数的作用是截取出数组中的一段，第二个参数表示从第几个元素开始截取，参数小于0时从后向前计算，第三个参数为正数 时，表示截取的长度，为负时，表示截取到末尾的第几个位置，第四个参数设置为true时，函数将保留键值，默认将会重置所有的数字键值。
<?php
$queue
=
array
(
7
=>
"
orange
"
,
8
=>
"
banana
"
,
9
=>
"
apple
"
,
10
=>
"
pear
"
)
;
$fruit
=
array_slice
(
$queue
,
1
,-
1
,
true
)
;
print_r
(
$fruit
)
;
/* 显示
Array
(
[8] => banana
[9] => apple
)
*/
?>
array_splice()函数的作用是将一个数组中的部分截取并替换。第二个参数表示截取的位置，小于0是表示从后往前计数，第三个参数为正时，表示截取的长度，为负时表示从后往前截取到的位置，第四个参数表示从第二个参数表示的位置开始插入内容的数组。
<?php
$input
=
array
(
"
red
"
,
"
green
"
,
"
blue
"
,
"
yellow
"
)
;
array_splice
(
$input
,
1
, -
1
)
;
print_r
(
$input
)
;
// 显示 array("red", "yellow")
$input
=
array
(
"
red
"
,
"
green
"
,
"
blue
"
,
"
yellow
"
)
;
array_splice
(
$input
,
1
,
count
(
$input
)
,
"
orange
"
)
;
print_r
(
$input
)
;
// 显示 array("red", "orange")
$input
=
array
(
"
red
"
,
"
green
"
,
"
blue
"
,
"
yellow
"
)
;
array_splice
(
$input
,
3
,
0
,
"
purple
"
)
;
print_r
(
$input
)
;
// 显示 array("red", "green", "blue", "purple", "yellow")
?>
shuffle()函数的作用是将数组打乱，并重建键名。
<?php
$input
=
array
(
"
Neok
"
=>
"
Neo
"
,
"
Morpheusk
"
=>
"
Morpheus
"
,
"
Trinityk
"
=>
"
Trinity
"
)
;
$rand_keys
=
shuffle
(
$input
)
;
print_r
(
$input
)
;
/*显示类似
Array
(
[0] => Trinity
[1] => Neo
[2] => Morpheus
)
*/
?>
array_rand()函数的作用是从数组中随机取出一个或多个单元的键名。第二个参数表示取出键的数量，省略则默认为1。
<?php
$input
=
array
(
"
Neok
"
=>
"
Neo
"
,
"
Morpheusk
"
=>
"
Morpheus
"
,
"
Trinityk
"
=>
"
Trinity
"
)
;
$rand_keys
=
array_rand
(
$input
,
2
)
;
print_r
(
$rand_keys
)
;
// 显示类似Array ( [0] => Neok [1] => Morpheusk )
?>
array_reverse()函数返回一个和原来数组相反的数组，第二个参数如果设置为TRUE则保留原来的键名。
<?php
$input
=
array
(
"
Neok
"
=>
"
Neo
"
,
"
Morpheusk
"
=>
"
Morpheus
"
,
"
Trinityk
"
=>
"
Trinity
"
)
;
$result
=
array_reverse
(
$input
)
;
print_r
(
$result
)
.
"
/n
"
;
/* 显示
Array
(
[Trinityk] => Trinity
[Morpheusk] => Morpheus
[Neok] => Neo
)
*/
?>
array_flip()函数的作用是交换数组中的键和值，函数要求值能够成为合法的键名，如果同一个值出现了多次，则最后一个键名将作为它的值，其它的将全部丢弃。
<?php
$trans
=
array
(
"
a
"
=>
1
,
"
b
"
=>
1
,
"
c
"
=>
2
)
;
$trans
=
array_flip
(
$trans
)
;
print_r
(
$trans
)
;
// 显示 Array ( [1] => b [2] => c )
?>
array_search()函数的作用是在数组中搜索给定的值，如果成功则返回相应的键名。第三个参数设置为true的时候将使用“===”进行比较，如果同一个值出现多次，则返回第一个匹配的键值。
<?php
$array
=
array
(
0
=>
'
blue
'
,
1
=>
'
red
'
,
2
=>
'
green
'
,
3
=>
'
red
'
)
;
echo
$key
=
array_search
(
'
green
'
,
$array
)
;
// 显示 2;
echo
$key
=
array_search
(
'
red
'
,
$array
)
;
// 显示 1;
?>
range()函数的作用是建立一个包含指定范围单元的数组，取字符值时候自动截取一位。第三个参数表示数组之间的间距，省略时默认为1。
<?php
print_r
(
range
(
'
1
'
,
'
5
'
,
'
2
'
))
;
/* 显示
Array
(
[0] => 1
[1] => 3
[2] => 5
)
*/
print_r
(
range
(
'
c
'
,
'
a
'
))
;
/* 显示
Array
(
[0] => c
[1] => b
[2] => a
)
*/
?>
array_fill()函数的作用是用给定的值填充数组，第一个参数表示开始的键值，第二个参数表示数组的长度，第三个参数表示数组的值。
<?php
$a
=
array_fill
(
-
1
,
2
,
array
(
'
first
'
,
'
key
'
=>
'
second
'
))
;
print_r
(
$a
)
;
/* 显示
Array
(
[-1] => Array
(
[0] => first
[key] => second
)
[0] => Array
(
[0] => first
[key] => second
)
)
*/
?>
array_pad()函数的作用是用值将数组填补到指定长度，如果第二个参数为正，则数组被填补到右侧，如果为负则从左侧开始填补。原数组里面的数字键值完全重置，字符串键值将保留。
<?php
$input
=
array
(
12
,
10
,
9
)
;
$result
=
array_pad
(
$input
, -
7
, -
1
)
;
print_r
(
$result
)
;
/* 显示
Array
(
[0] => -1
[1] => -1
[2] => -1
[3] => -1
[4] => 12
[5] => 10
[6] => 9
)
*/
?>
array_unique()函数的作用是移除数组中重复的值，保留首个出现的值。
<?php
$input
=
array
(
"
a
"
=>
"
green
"
,
"
red
"
,
"
b
"
=>
"
green
"
,
"
blue
"
,
"
red
"
)
;
$result
=
array_unique
(
$input
)
;
print_r
(
$result
)
;
/* 显示
Array
(
[a] => green
[0] => red
[1] => blue
)
*/
?>
array_intersect()函数的作用是计算若干个数组的交集。比较时不参考键值，但是键值不同时会保留前一个数组的键值。 array_uintersect()函数的作用和array_intersect()函数类似，区别是array_uintersect()函数使用回 调函数来比较。
<?php
$array1
=
array
(
"
a
"
=>
"
green
"
,
"
red
"
,
"
blue
"
)
;
$array2
=
array
(
"
b
"
=>
"
green
"
,
"
yellow
"
,
"
red
"
)
;
$result
=
array_intersect
(
$array1
,
$array2
)
;
print_r
(
$result
)
;
/* 显示
Array
(
[a] => green
[0] => red
)
*/
$array1
=
array
(
"
a
"
=>
"
green
"
,
"
b
"
=>
"
brown
"
,
"
c
"
=>
"
blue
"
,
"
red
"
)
;
$array2
=
array
(
"
a
"
=>
"
GREEN
"
,
"
B
"
=>
"
brown
"
,
"
yellow
"
,
"
red
"
)
;
print_r
(
array_uintersect
(
$array1
,
$array2
,
"
strcasecmp
"
))
;
/* 显示
Array
(
[a] => green
[b] => brown
[0] => red
)
*/
?>
array_intersect_key()函数的作用是使用键名比较计算数组的交集，如果值有冲突，则保留第一个数组中的值。 array_intersect_ukey()函数的作用和array_intersect_key()函数类似，区别是 array_intersect_ukey()函数可以使用最后一个参数设定一个回调函数来进行比较。
<?php
$array1
=
array
(
'
blue
'
=>
1
,
'
red
'
=>
2
,
'
green
'
=>
3
,
'
purple
'
=>
4
)
;
$array2
=
array
(
'
green
'
=>
1
,
'
blue
'
=>
2
,
'
yellow
'
=>
3
,
'
cyan
'
=>
4
)
;
$result
=
array_intersect_key
(
$array1
,
$array2
)
;
print_r
(
$result
)
;
/* 显示
Array
(
[blue] => 1
[green] => 3
)
*/
?>
array_intersect_assoc()函数使用对值和键值的联合比较的方式来计算多个数组的交集。 array_uintersect_assoc()函数，array_intersect_uassoc()函数， array_uintersect_uassoc()函数的作用和array_intersect_assoc()函数类似，区别是 array_uintersect_assoc()函数可以使用一个回调函数对值进行比较。array_intersect_uassoc()函数可以使 用一个回调函数对键值进行比较。array_uintersect_uassoc()函数可以使用两个回调函数同时对值和键值进行比较。
<?php
$array1
=
array
(
"
a
"
=>
"
green
"
,
"
b
"
=>
"
brown
"
,
"
c
"
=>
"
blue
"
,
"
red
"
)
;
$array2
=
array
(
"
a
"
=>
"
green
"
,
"
yellow
"
,
"
red
"
)
;
$result_array
=
array_intersect_assoc
(
$array1
,
$array2
)
;
print_r
(
$result_array
)
;
// 显示 Array ( [a] => green )
?>
array_diff()函数的作用是根据值来计算若干个数组相对于第一个数组参数的差集。比较时不参考键值。array_udiff()函数的作用和array_intersect()函数类似，区别是array_udiff()函数使用回调函数来比较。
<?php
$array1
=
array
(
"
a
"
=>
"
green
"
,
"
red
"
,
"
blue
"
,
"
red
"
)
;
$array2
=
array
(
"
b
"
=>
"
green
"
,
"
yellow
"
,
"
red
"
)
;
$result
=
array_diff
(
$array1
,
$array2
)
;
print_r
(
$result
)
;
// 显示 Array ( [1] => blue )
?>
array_diff_key()函数的作用是根据键值计算若干个数组相对于第一个数组参数的差集。 array_diff_ukey()函数的作用和array_diff_key()函数类似，区别是array_diff_ukey()函数可以使用最后 一个参数设定一个回调函数来进行比较。
<?php
$array1
=
array
(
'
blue
'
=>
1
,
'
red
'
=>
2
,
'
green
'
=>
3
,
'
purple
'
=>
4
)
;
$array2
=
array
(
'
green
'
=>
5
,
'
blue
'
=>
6
,
'
yellow
'
=>
7
,
'
cyan
'
=>
8
)
;
print_r
(
array_diff_key
(
$array1
,
$array2
))
;
/* 显示
Array
(
[red] => 2
[purple] => 4
)
*/
?>
array_diff_assoc()函数的作用是根据值和键值来计算若干个数组相对于第一个数组参数的差集。array_udiff_assoc ()函数，array_diff_uassoc()函数，array_udiff_uassoc()函数的作用和array_diff_assoc()函 数类似，区别是array_udiff_assoc()函数可以使用一个回调函数对值进行比较。array_diff_uassoc()函数可以使用一个 回调函数对键值进行比较。array_udiff_uassoc()函数可以使用两个回调函数同时对值和键值进行比较。
<?php
$array1
=
array
(
"
a
"
=>
"
green
"
,
"
b
"
=>
"
brown
"
,
"
c
"
=>
"
blue
"
,
"
red
"
)
;
$array2
=
array
(
"
a
"
=>
"
green
"
,
"
yellow
"
,
"
red
"
)
;
$result
=
array_diff_assoc
(
$array1
,
$array2
)
;
print_r
(
$result
)
;
/* 显示
Array
(
[b] => brown
[c] => blue
[0] => red
)
*/
?>
sort()函数的作用是对数组进行排序，第二个参数有4个常量可选，SORT_REGULAR：正常比较单元（不改变类型）； SORT_NUMERIC：单元被作为数字来比较；SORT_STRING：单元被作为字符串来比较；SORT_LOCALE_STRING：根据当前的 locale 设置来把单元当作字符串比较。rsort()函数的使用方法和sort()函数相同，区别是rsort()函数的排序是反向的。asort()函数的使用 方式和sort()函数相同，区别是asort()函数在排序后保留键值。arsort()函数的使用方法和sort()函数相同，区别是arsort ()函数的排序是反向且保留键值的。
<?php
$fruits
=
array
(
"
lemon
"
,
"
orange
"
,
"
banana
"
,
"
apple
"
)
;
sort
(
$fruits
)
;
print_r
(
$fruits
)
;
/* 显示
Array
(
[0] => apple
[1] => banana
[2] => lemon
[3] => orange
)
*/
$fruits
=
array
(
"
d
"
=>
"
lemon
"
,
"
a
"
=>
"
orange
"
,
"
b
"
=>
"
banana
"
,
"
c
"
=>
"
apple
"
)
;
asort
(
$fruits
)
;
print_r
(
$fruits
)
;
/* 显示
Array
(
[c] => apple
[b] => banana
[d] => lemon
[a] => orange
)
*/
?>
ksort()函数的作用是将数组按键名进行排序，第二个参数有4个常量可选，SORT_REGULAR：正常比较单元（不改变类型）； SORT_NUMERIC：单元被作为数字来比较；SORT_STRING：单元被作为字符串来比较；SORT_LOCALE_STRING：根据当前的 locale 设置来把单元当作字符串比较。krsort()函数的使用方法和ksort()函数相同，区别是krsort()函数的排序是反向的。
<?php
$fruits
=
array
(
"
d
"
=>
"
lemon
"
,
"
a
"
=>
"
orange
"
,
"
b
"
=>
"
banana
"
,
"
c
"
=>
"
apple
"
)
;
ksort
(
$fruits
)
;
print_r
(
$fruits
)
;
/* 显示
Array
(
[a] => orange
[b] => banana
[c] => apple
[d] => lemon
)
*/
$fruits
=
array
(
"
d
"
=>
"
lemon
"
,
"
a
"
=>
"
orange
"
,
"
b
"
=>
"
banana
"
,
"
c
"
=>
"
apple
"
)
;
krsort
(
$fruits
)
;
print_r
(
$fruits
)
;
/* 显示
Array
(
[d] => lemon
[c] => apple
[b] => banana
[a] => orange
)
*/
?>
usort()函数的作用是使用回调函数对数组进行排序，uasort()函数的使用方法和usort()函数相同，区别是uasort()函数比 较之后保留键值，uksort()函数的使用方法和usort()函数相同，区别是uksort()函数是对键值进行比较并排序。
<?php
function
cmp
(
$a
,
$b
)
{
return
strcmp
(
$a
,
$b
)
;
}
$fruits
=
array
(
"
lemons
"
,
"
apples
"
,
"
grapes
"
)
;
usort
(
$fruits
,
"
cmp
"
)
;
print_r
(
$fruits
)
;
/* 显示
Array
(
[0] => apples
[1] => grapes
[2] => lemons
)
*/
?>
natsort()函数的作用是使用“自然排序”法对数组排序，natcasesort()函数的作用和natsort()函数相同，区别是natcasesort()函数在比较是不区分大小写。
<?php
$array
=
array
(
"
img12.png
"
,
"
img10.png
"
,
"
img2.png
"
,
"
img1.png
"
)
;
natsort
(
$array
)
;
print_r
(
$array
)
;
/* 显示
Array
(
[3] => img1.png
[2] => img2.png
[1] => img10.png
[0] => img12.png
)
*/
?>
array_multisort()函数的作用是对多个数组进行排序，或者对多维数组进行排序，排序后字符串键名保持不变，但数字键名会被重新索 引。array_multisort()函数的参数形式非常古怪，规则是在每个数组参数后面，可以任意跟随两种形式的常量参数：第一种：排序顺序标志， SORT_ASC - 按照上升顺序排序，SORT_DESC - 按照下降顺序排序；第二种：排序类型标志，SORT_REGULAR - 将项目按照通常方法比较，SORT_NUMERIC - 将项目按照数值比较，SORT_STRING - 将项目按照字符串比较。
<?php
$ar
=
array
(
array
(
"
10
"
,
11
,
100
,
100
,
"
a
"
)
,
array
(
1
,
2
,
"
2
"
,
3
,
1
)
)
;
array_multisort
(
$ar
[
0
]
,
SORT_ASC
,
SORT_STRING
,
$ar
[
1
]
,
SORT_NUMERIC
,
SORT_DESC
)
;
print_r
(
$ar
)
;
/* 显示
Array
(
[0] => Array
(
[0] => 10
[1] => 100
[2] => 100
[3] => 11
[4] => a
)
[1] => Array
(
[0] => 1
[1] => 3
[2] => 2
[3] => 2
[4] => 1
)
)
*/
?>
current()函数的作用是返回数组的当前单元，pos()函数的作用和current()函数相同，是current()函数的别称， next()函数的作用是将指针指向数组的下一个单元，prev()函数的作用是将指针指向数组的上一个单元，end()函数的作用是将指针指向数组的最 后一个单元，reset()函数的作用是将指针指向数组的第一个单元，key()函数的作用是返回当前指针所在数组单元的键名。
<?php
$transport
=
array
(
'
foot
'
,
'
bike
'
,
'
car
'
,
'
plane
'
)
;
echo
$mode
=
next
(
$transport
)
;
// 显示 'bike';
echo
$mode
=
current
(
$transport
)
;
// 显示 = 'bike';
echo
$mode
=
prev
(
$transport
)
;
// 显示 = 'foot';
echo
$mode
=
end
(
$transport
)
;
// 显示 = 'plane';
echo
$mode
=
key
(
$transport
)
;
// 显示 3
echo
$mode
=
reset
(
$transport
)
;
// 显示 = 'foot';
?>
each()函数的作用是返回数组当前指针所在单元的键值和值，并将指针指向下一个单元，返回的数组有4个单元。
<?php
$foo
=
array
(
"
Robert
"
=>
"
Bob
"
,
"
Seppo
"
=>
"
Sepi
"
)
;
next
(
$foo
)
;
$bar
=
each
(
$foo
)
;
print_r
(
$bar
)
;
/* 显示
Array
(
[1] => Sepi
[value] => Sepi
[0] => Seppo
[key] => Seppo
)
*/
?>
list()函数的作用是将数组的值赋给一些变量。list()函数会从最左侧的变量开始赋值，在某些给出键值的数组赋值时，要注意顺序。
<?php
$info
=
array
(
'
coffee
'
,
'
brown
'
,
'
caffeine
'
)
;
list
(
$drink
,
$color
,
$power
)
=
$info
;
echo
$power
;
// 显示 caffeine
$info
=
array
(
'
coffee
'
,
'
brown
'
,
'
caffeine
'
)
;
list
(
$a
[
0
]
,
$a
[
1
]
,
$a
[
2
])
=
$info
;
print_r
(
$a
)
;
/* 显示
Array
(
[2] => caffeine
[1] => brown
[0] => coffee
)
*/
?>
array_map()函数的作用是对数组中的每个元素应用回调函数后返回结果。array_map()函数的第一个参数如果设置为“NULL”，则可以用一种有趣的方式来合并多个数组。
<?php
function
cube
(
$n
)
{
return
(
$n
*
$n
*
$n
)
;
}
$a
=
array
(
1
,
2
,
3
,
4
,
5
)
;
$b
=
array_map
(
"
cube
"
,
$a
)
;
print_r
(
$b
)
;
/* 显示
Array
(
[0] => 1
[1] => 8
[2] => 27
[3] => 64
[4] => 125
)
*/
$a
=
array
(
1
,
2
,
3
)
;
$b
=
array
(
"
one
"
,
"
two
"
,
"
three
"
)
;
$c
=
array
(
"
uno
"
,
"
dos
"
,
"
tres
"
)
;
$d
=
array_map
(
null
,
$a
,
$b
,
$c
)
;
print_r
(
$d
)
;
/* 显示
Array
(
[0] => Array
(
[0] => 1
[1] => one
[2] => uno
)
[1] => Array
(
[0] => 2
[1] => two
[2] => dos
)
[2] => Array
(
[0] => 3
[1] => three
[2] => tres
)
)
*/
?>
array_walk()函数的作用是对数组中的每个元素应用一个回调函数，回调函数中的第一个参数表示数组单元的值，第二个参数表示数组单元的键 值，第三个参数可以由array_walk()函数的第三个参数传递，使用引用：“&”可以对数组元素进行批量的修改。 array_walk_recursive()函数的使用方法和array_walk()函数一样，区别是array_walk_recursive() 函数会递归的作用于多维数组的所有单元。
注：没法对$key同时使用“&”，有点遗憾。
<?php
$fruits
=
array
(
"
d
"
=>
"
lemon
"
,
"
a
"
=>
"
orange
"
,
"
b
"
=>
"
banana
"
,
"
c
"
=>
"
apple
"
)
;
function
test_alter
(
&
$item1
,
$key
,
$prefix
)
{
$item1
=
"
$prefix
:
$item1
"
;
}
array_walk
(
$fruits
,
'
test_alter
'
,
'
fruit
'
)
;
print_r
(
$fruits
)
;
/*
Array
(
[d] => fruit: lemon
[a] => fruit: orange
[b] => fruit: banana
[c] => fruit: apple
)
*/
?>
array_filter()函数的作用是使用回调函数对数组进行过滤操作，所有返回为TRUE的数组单元都会被返回，无论是字符串键名还是数字键名，都保留不变。第二个参数如果省略，函数将会删去数组中所有值为false的单元。
<?php
function
odd
(
$var
)
{
return
(
$var
%
2
==
1
)
;
}
$array1
=
array
(
"
a
"
=>
1
,
"
b
"
=>
2
,
"
c
"
=>
3
,
"
d
"
=>
4
,
"
e
"
=>
5
)
;
print_r
(
array_filter
(
$array1
,
"
odd
"
))
;
/* 显示
Array
(
[a] => 1
[c] => 3
[e] => 5
)
*/
$entry
=
array
(
0
=>
'
foo
'
,
1
=>
false
,
2
=> -
1
,
3
=>
null
,
4
=>
''
)
;
print_r
(
array_filter
(
$entry
))
;
/* 显示
Array
(
[0] => foo
[2] => -1
)
*/
?>
array_reduce()函数的作用是对数组中的每个元素应用一个回调函数，第三个参数如果提供，将作用数组多出来的第一个元素。回调函数的第一个参数起到一个静态变量的作用，第二个参数表示数组的值，数组的键值则被丢弃。
<?php
function
rsum
(
$v
,
$w
)
{
$v
.=
$w
;
return
$v
;
}
$a
=
array
(
'
apple
'
=>
1
,
2
,
3
,
4
,
5
)
;
echo
$c
=
array_reduce
(
$a
,
"
rsum
"
,
10
)
;
// 显示 1012345
?>
array_change_key_case()函数的作用是转变数组中所有键值的大小写形式。第二个参数是一个常量参数：CASE_UPPER和 CASE_LOWER，CASE_UPPER表示转换成大小，CASE_LOWER表示转换为小写，省略时默认值是CASE_LOWER，如果在转变后出 现键值的重复，后一个数组单元的值将覆盖前一个。
<?php
$input_array
=
array
(
"
FirSt
"
=>
1
,
"
SecOnd
"
=>
4
)
;
print_r
(
array_change_key_case
(
$input_array
,
CASE_UPPER
))
;
/* 显示
Array
(
[FIRST] => 1
[SECOND] => 4
)
*/
?>
array_chunk()函数的作用是将一个数组拆成多个小单元，第二个参数表示每个小单元的数组个数，第三个可选参数，如果值为TRUE，则保留数组原来的键值，默认为false
<?php
$input_array
=
array
(
'
a
'
,
'
b
'
,
'
c
'
,
'
d
'
,
'
e
'
)
;
print_r
(
array_chunk
(
$input_array
,
2
,
true
))
;
/*
Array
(
[0] => Array
(
[0] => a
[1] => b
)
[1] => Array
(
[2] => c
[3] => d
)
[2] => Array
(
[4] => e
)
)
*/
?>
311
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
