PHP面试知识复习(八)——常用数组函数

属性

is_array

检测变量是否是数组

1
bool is_array(mixed $var)
1
2
$this->assertFalse(is_array(1));
$this->assertTrue(is_array([1]));

count

计算数组中的单元数目,或对象中的属性个数

1
int count(mixed $array_or_countable[, int $mode = COUNT_NORMAL])
1
$this->assertSame(5, count(range(1, 5)));
1
2
$this->assertSame(5, count([1, 2, 3, 4, 5 => range(1, 5)]));
$this->assertSame(10, count([1, 2, 3, 4, 5 => range(1, 5)], COUNT_RECURSIVE));

内部指针

reset

将数组的内部指针指向第一个单元

1
mixed reset(array &$array)
1
2
3
$data = range(1, 5);
end($data);
$this->assertSame(1, reset($data));
1
2
$data = [];
$this->assertFalse(reset($data));

prev

将数组的内部指针倒回一位

1
mixed prev(array &$array)
1
2
3
$data = range(1, 5);
end($data);
$this->assertSame(4, prev($data));
1
2
$data = range(1, 5);
$this->assertFalse(prev($data));

current

返回数组中的当前单元

1
mixed current(array &$array)
1
2
$data = range(1, 5);
$this->assertSame(1, current($data));
1
2
3
$data = range(1, 5);
prev($data);
$this->assertFalse(current($data));

next

将数组中的内部指针向前移动一位

1
mixed next(array &$array)
1
2
$data = range(1, 5);
$this->assertSame(2, next($data));
1
2
3
$data = range(1, 5);
end($data);
$this->assertFalse(next($data));

end

将数组的内部指针指向最后一个单元

1
mixed end(array &$array)
1
2
$data = range(1, 5);
$this->assertSame(5, end($data));
1
2
$data = [];
$this->assertFalse(end($data));

单数组

创建

array_combine

创建一个数组,用一个数组的值作为其键名,另一个数组的值作为其值

1
array array_combine(array $keys, array $values)
1
$this->assertSame([0 => 1, 1 => 2, 2 => 3], array_combine(range(0, 2), range(1, 3)));
1
2
3
$this->expectException('PHPUnit\Framework\Error\Warning');
$this->assertFalse(array_combine(range(0, 2), range(0, 3)));
$this->assertFalse(array_combine(range(0, 3), range(0, 2)));

range

根据范围创建数组,包含指定的元素

1
$this->assertSame([1, 2, 3], range(1, 3));
1
$this->assertSame(['a', 'b', 'c'], range('a', 'c'));
1
$this->assertSame(['a', 'b', 'c'], range('apple', 'car'));
1
$this->assertSame([-2, -1, 0, 1, 2], range(-2, 2));
1
$this->assertSame([3, 2, 1], range(3, 1));
1
$this->assertSame([1, 3], range(1, 3, 2));

array_fill

用给定的值填充数组

1
$this->assertSame([1, 1, 1], array_fill(0, 3, 1));
1
$this->assertSame([-2 => 1, 0 => 1, 1 => 1], array_fill(-2, 3, 1));
1
$this->assertSame([], array_fill(0, 0, 1));
1
2
$this->expectException('PHPUnit\Framework\Error\Warning');
$this->assertSame([], array_fill(0, -2, 1));
1
$this->assertSame([[1], [1], [1]], array_fill(0, 3, [1]));

array_fill_keys

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

1
array array_fill_keys(array $keys, mixed $value)
1
$this->assertSame([1 => 1, 2 => 1, 3 => 1], array_fill_keys(range(1, 3), 1));
1
$this->assertSame(['a' => 1, 'b' => 1, 'c' => 1], array_fill_keys(range('a', 'c'), 1));
1
$this->assertSame(['' => 1, 1 => 1], array_fill_keys([false, false, true], 1));
1
$this->assertSame([0 => [1, 2], 1 => [1, 2]], array_fill_keys(range(0, 1), [1, 2]));

堆栈

array_pop

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

1
mixed array_pop(array &$array)

array_pop() 弹出并返回 array 数组的最后一个单元,并将数组 array 的长度减一。

1
2
3
4
$data = range(1, 5);
$value = array_pop($data);
$this->assertSame([1, 2, 3, 4], $data);
$this->assertSame(5, $value);

array_push

将一个或多个单元压入数组的末尾(入栈)

1
int array_push(array &$array, mixed $value1[, mixed $...])
1
2
3
4
$data = range(1, 5);
$count = array_push($data, 6, 7);
$this->assertSame(range(1, 7), $data);
$this->assertSame(7, $count);

array_shift

将数组开头的单元移出数组

1
mixed array_shift(array &$array)

array_shift()array 的第一个单元移出并作为结果返回,将 array 的长度减一并将所有其它单元向前移动一位。所有的数字键名将改为从零开始计数,文字键名将不变。

1
2
3
4
$data = range(1, 5);
$value = array_shift($data);
$this->assertSame(range(2, 5), $data);
$this->assertSame(1, $value);
1
2
3
4
$data = ['a' => 1, 'b' => 2, 'c' => 3, 'd' => 4, 'e' => 5];
$value = array_shift($data);
$this->assertSame(['b' => 2, 'c' => 3, 'd' => 4, 'e' => 5], $data);
$this->assertSame(1, $value);

array_unshift

在数组开头插入一个或多个单元

1
int array_unshift(array &$array[, mixed $...])
1
2
3
4
$data = range(1, 5);
$count = array_unshift($data, -1, 0);
$this->assertSame(range(-1, 5), $data);
$this->assertSame(7, $count);
1
2
3
4
$data = ['a' => 1, 'b' => 2, 'c' => 3, 'd' => 4, 'e' => 5];
$count = array_unshift($data, -1, 0);
$this->assertSame([0 => -1, 1 => 0, 'a' => 1, 'b' => 2, 'c' => 3, 'd' => 4, 'e' => 5], $data);
$this->assertSame(7, $count);

修改

排序

sort
1
bool sort(array &$array[, int $sort_flags = SORT_REGULAR])

本函数对数组进行排序。当本函数结束时数组单元将被从最低到最高重新安排

  • 会重新赋予键名
  • 会修改原数组
  • 成功返回TRUE,失败返回FALSE
1
2
3
$data = [1, 3, 5, 2, 4];
sort($data);
$this->assertSame([1, 2, 3, 4, 5], $data);
1
2
3
$data = ['a', 'd', 'e', 'b', 'c'];
sort($data);
$this->assertSame(['a', 'b', 'c', 'd', 'e'], $data);
1
2
3
$data = ['img1', 'img2', 'img10', 'img20'];
sort($data);
$this->assertSame(['img1', 'img10', 'img2', 'img20'], $data);
asort
1
bool asort(array &$array[, int $sort_flags = SORT_REGULAR])

对数组进行排序并保持索引关系

  • 键名不变
  • 会修改原数组
  • 成功返回TRUE,失败返回FALSE
1
2
3
$data = [5 => 4, 4 => 3, 3 => 2, 2 => 1, 1 => 0];
asort($data);
$this->assertSame([1 => 0, 2 => 1, 3 => 2, 4 => 3, 5 => 4], $data);
ksort

对数组按照键名排序

1
bool ksort(array &$array[, int $sort_flags = SORT_REGULAR])
  • 值不变
  • 会修改原数组
  • 成功返回TRUE,失败返回FALSE
1
2
3
$data = ['c' => 1, 'b' => 1, 'd' => 2, 'e' => 10, 'a' => 2];
ksort($data);
$this->assertSame(['a' => 2, 'b' => 1, 'c' => 1, 'd' => 2, 'e' => 10], $data);
rsort
1
bool rsort(array &$array[, int $sort_flags = SORT_REGULAR])

对数组逆向排序

  • 会重新赋予键名
  • 会修改原数组
  • 成功返回TRUE,失败返回FALSE
1
2
3
$data = [1, 2, 3];
rsort($data);
$this->assertSame([3, 2, 1], $data);
arsort
1
bool arsort(array &$array[, int $sort_flags = SORT_REGULAR])

对数组进行逆向排序并保持索引关系

  • 键名不变
  • 会修改原数组
  • 成功返回TRUE,失败返回FALSE
1
2
3
$data = [1, 2, 3];
arsort($data);
$this->assertSame([2 => 3, 1 => 2, 0 => 1], $data);
krsort

对数组按照键名逆向排序

1
bool krsort(array &$array[, int $sort_flags = SORT_REGULAR])
  • 值不变
  • 会修改原数组
  • 成功返回TRUE,失败返回FALSE
1
2
3
$data = ['c' => 1, 'b' => 1, 'd' => 2, 'e' => 10, 'a' => 2];
krsort($data);
$this->assertSame(['e' => 10, 'd' => 2, 'c' => 1, 'b' => 1, 'a' => 2], $data);
usort

使用用户自定义的比较函数对数组中的值进行排序

1
bool usort(array &$array, callable $value_compare_func)
  • 会修改键名
  • 比较函数在第一个参数小于,等于或大于第二个参数时,必须相应地返回一个小于,等于或大于 0 的整数

    1
    int callback(mixed $a, mixed $b)
  • 成功返回TRUE,失败返回FALSE

1
2
3
4
5
6
7
8
$data = [3, 2, 1];
usort($data, function($a, $b) {
if ($a == $b) {
return 0;
}
return ($a < $b) ? -1 : 1;
});
$this->assertSame([1, 2, 3], $data);
uasort

使用用户自定义的比较函数对数组中的值进行排序并保持索引关联

1
bool uasort(array &$array, callable $value_compare_func)
  • 会保留键名
  • 比较函数在第一个参数小于,等于或大于第二个参数时,必须相应地返回一个小于,等于或大于 0 的整数

    1
    int callback(mixed $a, mixed $b)
  • 成功返回TRUE,失败返回FALSE

1
2
3
4
5
6
7
8
$data = [3, 2, 1];
uasort($data, function($a, $b) {
if ($a == $b) {
return 0;
}
return ($a < $b) ? -1 : 1;
});
$this->assertSame([2 => 1, 1 => 2, 0 => 3], $data);
uksort

使用用户自定义的比较函数对数组中的键名进行排序

1
bool uksort(array &$array, callable $key_compare_func)
  • 比较函数在第一个参数小于,等于或大于第二个参数时,必须相应地返回一个小于,等于或大于 0 的整数

    1
    int callback(mixed $a, mixed $b)
  • 成功返回TRUE,失败返回FALSE

1
2
3
4
5
6
7
8
$data = ['c' => 1, 'b' => 1, 'd' => 2, 'e' => 10, 'a' => 2];
uksort($data, function($a, $b) {
if ($a == $b) {
return 0;
}
return ($a < $b) ? -1 : 1;
});
$this->assertSame(['a' => 2, 'b' => 1, 'c' => 1, 'd' => 2, 'e' => 10], $data);
natsort

用“自然排序”算法对数组排序

1
bool natsort(array &$array)
  • 保留键名
  • 会修改原数组
  • 成功返回TRUE,失败返回FALSE
1
2
3
$data = ['img1', 'img2', 'img10', 'img20'];
natsort($data);
$this->assertSame(['img1', 'img2', 'img10', 'img20'], $data);
natcasesort

用“自然排序”算法对数组进行不区分大小写字母的排序

1
bool natcasesort(array &$array)
  • 保留键名
  • 会修改原数组
  • 成功返回TRUE,失败返回FALSE
1
2
3
4
$data = ['img1', 'IMG2', 'img10', 'IMG20'];
natcasesort($data);
$this->assertSame(['img1', 'IMG2', 'img10', 'IMG20'], $data);
?>
array_reverse

返回单元顺序相反的数组

1
array array_reverse(array $array[, bool $preserve_keys = FALSE])
1
$this->assertSame([3, 2, 1], array_reverse([1, 2, 3]));
1
$this->assertSame([2 => 3, 1 => 2, 0 => 1], array_reverse([1, 2, 3], true));
shuffle

打乱数组

1
bool shuffle(array &$array)
  • 不保留键名
  • 伪随机
  • 成功返回TRUE,失败返回FALSE

键值交换

array_flip

交换数组中的键和值

1
array array_flip(array $array)
1
$this->assertSame([1 => 0, 2 => 1, 3 => 2, 4 => 3, 5 => 4], array_flip(range(1, 5)));
1
$this->assertSame([1 => 4], array_flip(array_fill(0, 5, 1)));
1
2
$this->expectException('PHPUnit\Framework\Error\Warning');
$this->assertSame([0 => 1], array_flip([false, 0, false]));

查询

in_array

检查数组中是否存在某个值

1
bool in_array(mixed $needle, array $haystack[, bool $strict = FALSE])

大海捞针,在大海(haystack)中搜索针( needle),如果没有设置 strict 则使用宽松的比较。

如果找到 needle 则返回 TRUE,否则返回 FALSE

1
2
$this->assertTrue(in_array(1, ['1']));
$this->assertTrue(in_array(1, [1]));
1
2
$this->assertFalse(in_array(1, ['1'], true));
$this->assertTrue(in_array(1, [1], true));

在数组中搜索给定的值,如果成功则返回首个相应的键名

1
mixed array_search(mixed $needle, array $haystack[, bool $strict = false])
1
$this->assertEquals(0, array_search(1, [1]));
1
$this->assertEquals(0, array_search(1, [1, 1]));
1
$this->assertFalse(array_search('1', [1], true));

array_key_exists

检查数组里是否有指定的键名或索引

1
bool array_key_exists(mixed $key, array $array)
1
2
$this->assertTrue(array_key_exists(1, ['a', 'b']));
$this->assertFalse(array_key_exists(1, ['a']));

array_key_exists() 仅仅搜索第一维的键。 多维数组里嵌套的键不会被搜索到。

1
$this->assertFalse(array_key_exists(1, [['a', 'b']]));

array_keys

返回数组中部分的或所有的键名

1
array array_keys(array $array[, mixed $search_value = null[, bool $strict = false]])
1
$this->assertEquals([0, 1, 2, 3, 4], array_keys(range(1, 5)));
1
$this->assertEquals([0], array_keys(range(1, 5), 1));
1
$this->assertSame([], array_keys(range(1, 5), '1', true));
1
$this->assertSame([], array_keys([[1], 2, 3], 1));

array_values

1
array array_values(array $array)

返回数组中所有的值

1
$this->assertSame([1, 2, 3], array_values(['a' => 1, 'b' => 2, 'c' => 3]));

筛选

array_unique

移除数组中重复的值

1
array array_unique(array $array[, int $sort_flags = SORT_STRING])
1
$this->assertSame(['a' => 'b'], array_unique(['a' => 'b', 'b' => 'b']));

array_slice

从数组中取出一段

1
array array_slice(array $array, int $offset[, int $length = NULL[, bool $preserve_keys = false]])
1
$this->assertSame(range('a', 'e'), array_slice(range('a', 'e'), -5));
1
$this->assertSame(range('d', 'e'), array_slice(range('a', 'e'), -2));
1
$this->assertSame(range('a', 'e'), array_slice(range('a', 'e'), 0));
1
$this->assertSame(range('c', 'e'), array_slice(range('a', 'e'), 2));
1
$this->assertSame([], array_slice(range('a', 'e'), 5));

回调

array_map

为数组的每个元素应用回调函数

1
array array_map(callable $callback, array $array1[, array $...])
1
2
3
4
$data = range(1, 5);
$this->assertEquals([1, 4, 9, 16, 25], array_map(function($n) {
return $n * $n;
}, $data));

array_walk

使用用户自定义函数对数组中的每个元素做回调处理

1
bool array_walk(array &$array, callable $callback[, mixed $userdata = NULL])

array_walk() 不会受到 array 内部数组指针的影响。array_walk() 会遍历整个数组而不管指针的位置

参数
array

输入的数组。

callback

典型情况下 callback 接受两个参数。array 参数的值作为第一个,键名作为第二个。

userdata

如果提供了可选参数 userdata,将被作为第三个参数传递给 callback funcname。

使用
1
2
3
4
5
$data = range(1, 5);
array_walk($data, function(&$value, $key) {
$value *= $value;
});
$this->assertEquals([1, 4, 9, 16, 25], $data);

array_filter

用回调函数过滤数组中的单元

1
array array_filter(array $array[, callable $callback[, int $flag = 0]])

依次将 array 数组中的每个值传递到 callback 函数

  • 如果 callback 函数返回 true,则 array 数组的当前值会被包含在返回的结果数组中
  • 数组的键名保留不变

    1
    2
    3
    4
    $data = range(0, 5);
    $this->assertEquals([0 => 0, 2 => 2, 4 => 4], array_filter($data, function($val) {
    return $val % 2 == 0;
    }));
  • 如果没有提供 callback 函数, 将删除 array 中所有等值为 FALSE 的条目

    1
    2
    $data = range(0, 5);
    $this->assertEquals([1 => 1, 2 => 2, 3 => 3, 4 => 4, 5 => 5], array_filter($data));

array_reduce

用回调函数迭代地将数组简化为单一的值

1
mixed array_reduce(array $array, callable $callback[, mixed $initial = NULL])
参数
array

输入的 array。

callback
1
mixed callback(mixed $carry, mixed $item)

####### carry

携带上次迭代里的值; 如果本次迭代是第一次,那么这个值是 initial

####### item

携带了本次迭代的值。

initial

如果指定了可选参数 initial,该参数将在处理开始前使用,或者当处理结束,数组为空时的最后一个结果。

使用
1
2
3
4
$data = range(1, 100);
$this->assertEquals(5050, array_reduce($data, function($carry, $item) {
return $carry + $item;
}));
1
2
3
4
$data = range(1, 100);
$this->assertEquals(5051, array_reduce($data, function($carry, $item) {
return $carry + $item;
}, 1));
1
2
3
4
5
$data = range(1, 100);
$this->assertEquals(1, array_reduce($data, function($carry, $item) {
unset($item);
return $carry;
}, 1));

多数组

集合

array_diff

计算数组的差集

1
array array_diff(array $array1, array $array2[, array $...])

对比 array1 和其他一个或者多个数组,返回在 array1 中但是不在其他 array 里的值。

1
$this->assertSame([], array_diff(['a'], [1, 'a']));

array_diff_assoc

带索引检查计算数组的差集

1
array array_diff_assoc(array $array1, array $array2[, array $...])

array_diff_assoc() 返回一个数组,该数组包括了所有在 array1 中但是不在任何其它参数数组中的值。注意和 array_diff() 不同的是键名也用于比较。

1
$this->assertSame(['a'], array_diff_assoc(['a'], [1, 'a']));

array_intersect

计算数组的交集

1
array array_intersect(array $array1, array $array2[, array $...])

array_intersect() 返回一个数组,该数组包含了所有在 array1 中也同时出现在所有其它参数数组中的值。注意键名保留不变。

1
2
3
4
$this->assertSame(['a'], array_intersect(['a'], [1, 'a']));
$this->assertSame(['a'], array_intersect(['a'], ['a', 1]));
$this->assertSame([1 => 'a'], array_intersect([1 => 'a'], [1, 'a']));
$this->assertSame([1 => 'a'], array_intersect([1 => 'a'], ['a', 1]));

array_intersect_assoc

带索引检查计算数组的交集

1
array array_intersect_assoc(array $array1, array $array2[, array $...])

array_intersect_assoc() 返回一个数组,该数组包含了所有在 array1 中也同时出现在所有其它参数数组中的值。注意和 array_intersect() 不同的是键名也用于比较。

1
2
$this->assertSame(['a'], array_intersect_assoc(['a'], ['a', 1]));
$this->assertNotSame(['a'], array_intersect_assoc(['a'], [1, 'a']));

合并

array_merge

合并一个或多个数组

1
array array_merge(array $array1 [, array $...])
1
$this->assertSame(range('a', 'g'), array_merge(range('a', 'c'), range('d', 'g')));
1
$this->assertSame(['a' => 1, 'b' => 2, 0 => 3, 1 => 3], array_merge(['a' => 2, 'b' => 4, 3 => 3], ['a' => 1, 'b' => 2, 3 => 3]));

array_merge_recursive

递归地合并一个或多个数组

1
array array_merge_recursive(array $array1 [, array $...])
1
$this->assertSame(['a' => range('a', 'g'), 'b' => 1], array_merge_recursive(['a' => range('a', 'c'), 'b' => 1], ['a' => range('d', 'g')]));
1
$this->assertSame(['a' => ['a' => [2, 1], 'b' => [4, 2]]], array_merge_recursive(['a' => ['a' => 2, 'b' => 4]], ['a' => ['a' => 1, 'b' => 2]]));
1
$this->assertSame(['a' => [2, 1], 'b' => [4, 2], 0 => 3, 1 => 3], array_merge_recursive(['a' => 2, 'b' => 4, 3 => 3], ['a' => 1, 'b' => 2, 3 => 3]));