数组内容操作

array_change_key_case: 将数组键名修改为全大写或全小写
array_column: 提取出数组元素中的指定键
array_filter: 对数组中的值进行过滤
array_walk: 对数组中每个元素都通过函数进行处理
array_walk_recursive: 对数组中每个元素经过函数进行处理, 递归数组
array_count_values: 统计数组中值的次数, 返回统计结果
array_diff_assoc: 多个数组做差集, 键值相同
array_diff_uassoc: 多个数组做差集, 键值相同, 使用用户函数比较
array_diff_key: 多个数组做差集,键相同
array_diff_ukey: 多个数组做差集,键相同, 使用用户函数比较
array_diff: 多个数组做差集, 值相同
array_udiff_assoc: 多个数组做差集, 键值相同, 使用用户函数比较
array_udiff_uassoc: 多个数组做差集, 键值相同, 使用用户函数比较
array_udiff: 多个数组做差集, 值相同, 使用用户函数比较
array_flip: 将数组键值反转
array_map: 对多个数组值通过用户函数进行处理, 返回处理后的新数组
array_intersect_assoc: 多个数组做交集, 键值均相同
array_intersect_uassoc: 多个数组做交集, 键值均相同, 使用用户函数比较
array_intersect_key: 多个数组做交集, 键相同, 值为第一个数组的值
array_intersect_ukey: 多个数组做交集, 键相同, 值为第一个数组的值, 使用用户函数比较
array_intersect: 多个数组做交集, 值相同, 键使用第一个数组的
array_uintersect_assoc: 多个数组做交集, 键值相同, 使用用户函数比较
array_uintersect_uassoc: 多个数组做交集, 值相同, 使用用户函数比较
array_uintersect: 多个数组做交集, 值相同, 用户函数比较
array_pad: 将数组扩容到指定大小
array_product: 计算数组所有值的乘积
array_sum: 计算数组所有值的和
array_rand: 从数组中随机取n个键
array_reduce: 数组中所有元素递归通过用户函数进行计算, 返回最终计算结果
array_reverse: 数组倒序
array_unique: 移除数组重复的值
array_unshift: 在数组开头插入元素
asort: 排序, 保持键值关系
natsort: 使用自然排序对数组进行排序
natcasesort: 使用自然排序对数组进行排序, 不区分大小写
arsort: 逆向排序,保持键值关系
sort: 排序
ksort: 数组按照键排序, 参数与 sort 相同
krsort: 数组按照键逆向排序, 参数与 sort 相同
rsort: 数组逆向排序, 参数与 sort 相同
usort: 数组按照值排序, 使用用户函数, 重排索引
uksort: 数组按照键排序, 参数与 usort 相同
uasort: 数组按照值排序, 保持键值关系, 参数与 usort 相同
shuffle: 将数组顺序打乱
array_multisort: 对多个数组或多维数组进行排序
extract: 将数组中的内容提取为变量, 键为变量名, 值为变量值

数组搜索

count: 计算数组长度
sizeof: count 的别名
array_key_exists: 数组是否存在指定键
key_exists: array_key_exists 函数的别名
array_key_first: 获取数组第一个键
array_key_last: 获取数组最后一个键
end: 获取数组最后一个元素的值
array_pop: 弹出数组最后一个元素
array_push: 将值压入数组末尾
array_shift: 弹出数组第一个元素
in_array: 指定值在数组中是否存在
array_search: 返回数组中指定值的第一个键
current: 返回数组内部指针指向的当前元素
each: 返回数组内部指针指向的当前元素键值, 并将指针向前移动一位
pos: current的别名
next; 将数组指针指向下一个, 并返回下一个元素
prev: 将数组指针指向前一个, 并返回前一个元素
reset: 将数组指针指向第一个, 并返回元素
list: 将数组的元素依次赋值给指定变量

切分

array_chunk: 按长度将数组进行切分
array_values: 返回数组所有值
array_keys: 返回数组所有键
array_slice: 切下数组的指定段落
array_splice: 将数组的指定部分使用新数组取代

合并

array_merge: 合并一个或多个数组
array_merge_recursive: 合并一个或多个数组, 递归处理
array_replace: 合并数组, 相同键时, 使用后面数组的内容
array_replace_recursive: 合并数组, 相同键使用后面数组的内容, 递归处理

创建数组

array: 新建数组
array_fill: 创建指定索引开始, 指定长度, 指定值的数组
array_combine: 将两数组合并,一个数组作为键,一个数组作为值
array_fill_keys: 将arr1的值作为key, arr2的值作为value, 返回新数组
compact: 将现存的变量包含到数组中
range: 按照给定的范围创建数组

方法解释

array_change_key_case

将数组键名修改为全大写或全小写, 返回是否成功

array_change_key_case($arr, $case=CASE_LOWER)

arr: 要改变的数组
case: 模式选择
CASE_UPPER: 大写
CASE_LOWER: 小写

注意: 如果数组中多个键经过转换, 变成一样的, 如 key和kEY, 那么, 后面的值会覆盖掉前面的值

array_chunk

将数组切分为指定长度的n个数组, 返回切割后的数组列表

array_chunk($arr, $size, $preserve_keys=false)

arr: 要进行切割的数组
size: 切割后每个数组的长度
preserve_keys: 是否保留原数组的索引
true: 保留
false: 不保留,新数组索引从0开始

array_column

将数组中键为key的所对应的值提取出来, 返回提取后的数组

array_column($arr, $key, $index_key=null)

arr: 指定数组
key: 要提取的键值
index_key: 指定作为返回数组键的列

$arr = [
[
'id' => '王二id',
'name' => '王二',
],
[
'id' => '李四id',
'name' => '李四',
],
];

$a = array_column($arr, 'name');
/*
Array
(
[0] => 王二
[1] => 李四
)
*/
$a = array_column($arr, 'name', 'id');
/* 将id作为结果的索引
Array
(
[王二id] => 王二
[李四id] => 李四
)
*/
// 如果数组内容是对象怎么办?
class User{
public $username;
public function __construct(string $username)
{
$this->username = $username;
}
}
$arr = [
new User('王二'),
new User('李四'),
];
$a = array_column($arr, 'username');
/* 也就是说, 可以直接拿到对象的public属性
Array
(
[0] => 王二
[1] => 李四
)
*/
class User2{
private $username;
public function __construct(string $username)
{
$this->username = $username;
}
public function __get($prop)
{
return $this->$prop;
}
public function __isset($prop) : bool
{
return isset($this->$prop);
}
}
$arr = [
new User('王二'),
new User('李四'),
];
$a = array_column($arr, 'username');
/* 私有属性需要通过 __get 魔术方法获取
若不提供 __isset 方法会返回空数组, 因为会先通过该方法判断是否存在
Array
(
[0] => 王二
[1] => 李四
)
*/

array_combine

将两数组合并, 使用keys数组作为新数组的键, 使用values数组作为新数组的值, 返回合并后的数组, 若两数组元素个数不同, 返回false

array_combine($keys, $values)

array_merge

将多个数组合并为一个数组, 返回合并后的数组

array_merge($arr, [$arr, ...])

　　若存在键冲突, 后面的数组内容会覆盖前面的内容, 但如果键为数字, 会进行重新排序从0开始, 后面的向后排.

　　如果存在键冲突时, 忽略后面键的内容, 请使用 + 连接两数组

array_merge_recursive

将多个数组合并为一个数组, 返回合并后的数组

array_merge_recursive($arr, [$arr, ...])

　　此函数与 array_merge 的不同, 在于对相同键时的处理不同

　　此函数会将相同键的内容合并为数组, 一直递归合并下去

array_replace

将多个数组合并, 返回合并后的数组

array_replace($arr, [$arr, ...])

　　此函数于 array_merge 的不同, 在于对数字索引的处理, 此函数不会重排, 而是直接使用后面的内容替换

array_replace_recursive

将多个数组合并, 返回合并后的数组

array_replace_recursive($arr, [$arr, ...])

　　此函数与 array_replace 的不同, 在于此函数会递归比较, 将数组中的数组都进行比较

array_walk

对数组中的每个元素通过callback进行处理

array_walk($arr, $callback, $userdata=null)

arr: 数组
callback: 回调函数, 参数为值,键,userdata

$arr = [
1 => 4,
3 => 2,
];
$a = array_walk($arr, function (&$value, $key){
$value += $key;
});
/* 每次将键值相加, 赋给值
Array
(
[1] => 5
[3] => 5
)
*/

array_walk_recursive

对数组中的每个元素通过函数进行处理

array_walk_recursive($arr, $callback, $userdata=null)

　　与 array_walk 不同的, 此函数会递归数组中的每个数组

array_values

将数组的所有值, 作为新的数组返回

array_values($arr)

array_keys

将数组的所有键,作为新的数组返回

array_keys($arr)

array_count_values

统计数组中值的次数, 返回统计数组(键为原数组值, 值为次数)

array_count_values($arr)

$arr = [
'1', '你好', '1', '我们',
];
$a = array_count_values($arr);
/*
Array
(
[1] => 2
[你好] => 1
[我们] => 1
)
*/

array_diff_assoc

返回新数组(键值对在arr数组,不在其他数组)

array_diff_assoc($arr, $arr2, [$arr3, ...])

array_diff_uassoc

返回新数组(键值对在arr数组,不在其他数组, 使用自定义函数进行比较)

array_diff_uassoc($arr, $arr2, [$arr3, ...], $fun)

fun: 比较两值是否相等(0)小于(负数)大于(正数)

array_diff_key

返回新数组(键在arr数组, 不再其他数组)

array_diff_key($arr, $arr2, [$arr3, ...])

array_diff_ukey

返回新数组(键在arr数组, 不再其他数组, 使用用户函数进行比较)

array_diff_ukey($arr, $arr2, [$arr3, ...], $fun)

array_diff

返回新数组(值在arr数组, 不再其他数组)

array_diff($arr, $arr2, [$arr3, ...])

array_fill_keys

将arr的值作为新数组的key, arr2的值作为新数组的value, 返回新数组

array_fill_keys($arr, $arr2)

　　与 array_combine 不同, 此函数不会比较两数组长度

array_fill

返回索引以index开始, 长度为num, 值为value的数组

array_fill($index, $num, $value)

array_filter

将数组中所有键通过callback进行过滤, 返回过滤后的数组

array_filter($arr, $callback, $flag=0)

clasback: 过滤函数, 返回值为true则包含到新数组, 返回值为false则过滤
flag: 过滤函数接收的参数类型
- ARRAY_FILTER_USE_KEY: 参数为键
- ARRAY_FILTER_USE_BOTH: 参数为键和值

array_flip

将数组中键值反转

array_flip($arr)

　　若反转后同一个键有多个值, 使用最后一个值

array_key_exists

指定的键在数组中是否存在

array_key_exists($key, $arr)

array_key_first

返回数组第一个键

array_key_first($arr)

array_key_last

返回数组最后一个键

array_key_last($arr)

array_map

对数组的值经过函数处理后, 作为新的值

array_map($callback, $arr1, [$arr2, ...])

callback: 用户函数, 参数与传入的数组数量相同, 拿到每个数组的值后, 返回处理后的值作为返回数组的值
若传入null, 则会创建多维数组

array_pop

弹出数组最后一个元素(出栈)

array_pop($arr)

array_push

将值压入数组末尾(入栈)

array_push($arr, $value1, [$value2, ...])

array_intersect_assoc

返回多个数组键值对均相同的

array_intersect_assoc($arr, $arr2, [$arr3, ...])

array_intersect_uassoc

返回多个数组中键值均相同的, 通过用户函数比较

array_intersect_uassoc($arr, $arr2, [$arr3, ...], $fun)

fun: 比较函数, 参数为两个值, 返回第一个参数小于(负数), 等于(0), 大于(正数)第二个参数

array_intersect_key

返回键存在在arr中, 并同时在其他数组中也存在的

array_intersect_key($arr, $arr2, [$arr3, ...])

array_intersect_ukey

返回键存在于arr中, 并同时存在于其他数组中的, 通过用户函数比较

array_intersect_ukey($arr, $arr2, [$arr3, ...], $fun)

array_intersect

返回值在arr中, 同时在其他数组存在的

array_intersect($arr, $arr2, [$arr3, ...])

in_array

判断值是否在数组中

in_array($value, $arr, $flag=false)

flag: 是否连同变量类型一起检查

end

返回数组最后一个元素的值

end($arr)

array

创建一个数组, 参数为数组信息

array($arr)

array_pad

将数组扩充到指定大小, 使用value填充

array_pad($arr, $size, $value)

size: 新数组的大小, 若不足, 则填充, 正数从右侧填充, 负数从左侧填充

array_rand

从数组中随机取出num个元素的键

array_rand($arr, $num=1)

array_reduce

递归数组所有的值, 通过函数计算, 返回最终值

array_reduce($arr, $callback, $i=null)

callback: 参数为, 上次计算的值(第一次为$i), 本次的值

array_reverse

将数组倒序并返回

array_reverse($arr, $flag=false)

flag: 数组索引是否保留

array_search

在数组中查找指定值是否存在, 若存在, 返回键名

array_search($value, $arr, $flag=false)

flag: 是否比较类型

array_shift

将数组的第一个元素弹出(队列)

array_shift($arr)

array_slice

切下数组指定的一段

array_slice($arr, $offset, $length=null, $flag=false)

offset: 偏移量, 负数从末尾开始
length: 长度, 正数从偏移量向后数, 负数则终止在据末尾指定长度位置, null则一直到末尾
flag: 是否取消数字索引的重排

array_splice

去掉数组的指定部分, 使用新的数组取代

array_splice($arr, $offset, $lenght=count($arr), $rarr=array())

array_udiff_uassoc

键值在arr中, 同时不在其他数组中的, 用户函数比较

array_udiff_uassoc($arr, $arr2, [$arr3, ...], $fun)

array_udiff_assoc

键值在arr中, 同时不在其他数组中的, 用户函数比较

array_udiff_assoc($arr, $arr2, [$arr3, ...], $fun)

array_unique

去掉数组中重复的值(将值进行排序, 然后相同的值取第一个)

array_unique($arr, $flag=SORT_STRING)

flag: 排序行为
- SORT_REGULAR: 通常方法排序,不改变类型
- SORT_NUMERIC; 按数字排序
- SORT_STRING: 按字符串排序
- SORT_LOCALE_STRING: 根据当前本地设置, 按字符串排序

array_unshift

将值插入到数组的开头

array_unshift($arr, [$value1, ...])

asort

数组排序, 保持键值关系

asort($arr, $flag=SORT_REGULAR)

flag: 排序方式
- SORT_REGULAR: 正常比较, 不改变类型
- SORT_NUMERIC: 当作数字比较
- SORT_STRING: 当作字符串比较
- SORT_LOCALE_STRING: 根据本地设置, 当作字符串比较, 可使用 setlocale() 函数改变
- SORT_NATURAL: 对每个以自然的顺序对字符串排序
- SORT_FLAG_CASE: 字符串排序不区分大小写

arsort

数组逆向排序, 保持键值关系

arsort($arr, $flag=SORT_REGULAR)

sort

数组排序

sort($arr, $flag=SORT_REGULAR)

flag: 排序方式
- SORT_REGULAR: 正常比较, 不改变类型
- SORT_NUMERIC: 当作数字比较
- SORT_STRING: 当作字符串比较
- SORT_LOCALE_STRING: 根据本地设置, 当作字符串比较, 可使用 setlocale() 函数改变
- SORT_NATURAL: 对每个以自然的顺序对字符串排序
- SORT_FLAG_CASE: 字符串排序不区分大小写

usort

对数组中的值进行排序, 使用用户函数, 会重排索引

usort($arr, $fun)

fun: 比较函数, 第一个参数小于(负数), 等于(0), 大于(正数) 第二个参数

compact

将传入的参数作为变量名, 键为变量名, 值为变量, 返回新数组

compact($v1, [$v2, ...])

$v1 = "abc";
$v2 = "bcd";
$v3 = 'efg";
$arr = array('v2', 'v3');
$a = compact('v1', 'nothing', $arr);
/*
Array(
[v1] => 'abc',
[v2] => 'bcd',
[v3] => 'efg',
)
*/

range

创建从start开始, 到end结束, 步长为step的数组

range($start, $end, $step=1)

list

将数组中的值赋给变量, 可以在单次操作为一组变量赋值

list($a, $b, ...)

$arr = [
'你好', '我们',
];
// $a='你好', $b='我们'
list($a, $b) = $arr;

extract

将数组中的键值对导出为变量

extract($arr, $flag=EXTR_OVERWRITE, $frefix=null)

flag: 当键为非法变量名, 或与当前已有变量冲突时, 将如何操作
- EXTR_OVERWRITE: 冲突时, 覆盖已有变量
- EXTR_SKIP: 冲突时, 不覆盖已有变量
- EXTR_PREFIX_SAME: 冲突时, 在变量名前加 prefix 前缀
- EXTR_PREFIX_ALL: 所有变量名加 prefix 前缀
- EXTR_PREFIX_INVALID: 非法变量名加 prefix 前缀
- EXTR_IF_EXISTS: 仅当已有同名变量时, 覆盖已有变量的值, 不存在则不处理, 如定义变量后, 从$_REQUEST中导入这些变量
- EXTR_PREFIX_IF_EXISTS: 仅当已有同名变量时, 建立加 prefix 前缀的变量, 其他不处理
- EXTR_REFS: 将变量作为引用提取, 可以与其他标志 or 一起使用, 引用指向数组内容
frefix: 变量名前缀

array_multisort

对多个数组或多维数组进行排序
array_multisort($arr, $order=SORT_ASC, $flag=SORT_REGULAR, ...)

order: 升序或降序
- SORT_ASC: 升序
- SORT_DESC: 降序
flag: 排序的类型
- SORT_REGULAR: 正常排序, 不修改类型
- SORT_NUMERIC: 按数字大小排序
- SORT_STRING: 按字符串比较
- SORT_LOCALE_STRING: 根据本地设置, 按字符串比较. 使用local信息, 可通过 setlocale() 修改
- SORT_NATURAL: 按字符串自然排序, 类似 natsort()
- SORT_FLAG_CASE: 大小写不敏感方式, 可与 SORT_STRING SORT_NATURAL 通过or一起使用
…: 可提供多个数组, 多个数组需要有相同数量的元素

原文地址 https://hujingnb.com/archives/237

转载请保留原文连接: PHP 数组函数整理 | 烟草的香味