PHP函数参考25-常用数组函数

array_change_key_case — 将数组中的所有键名修改为全大写或小写

将 array 数组中的所有键名改为全小写或大写。本函数不改变数字索引。
array_chunk — 将一个数组分割成多个

将一个数组分割成多个数组，其中每个数组的元素数目由 size 决定。最后一个数组的元素数目可能会少于 size 个。

得到的数组是一个**多维数组**中的元素，其索引从零开始，每一维包含了 size 个元素。

array_column — 返回数组中指定的一列

array_column( array $input, mixed $column_key[, mixed $index_key = null] ) : array

array_column() 返回input数组中键值为column_key的列，如果指定了可选参数index_key，那么input数组中的这一列的值将作为返回数组中对应值的键。

抽取数组中的一列组成一个新的数组，新数组的索引可以通过第三个参数index_key来指定（从原input二维数组指定各个子数组中的索引key）

$records = array(
    array(
        'id' => 2135,
        'first_name' => 'John',
        'last_name' => 'Doe',
    ),
    array(
        'id' => 3245,
        'first_name' => 'Sally',
        'last_name' => 'Smith',
    ),
    array(
        'id' => 5342,
        'first_name' => 'Jane',
        'last_name' => 'Jones',
    ),
    array(
        'id' => 5623,
        'first_name' => 'Peter',
        'last_name' => 'Doe',
    )
);    
$last_names = array_column($records, 'last_name', 'id');
print_r($last_names);

从数组records中抽取各个子数组中的列last_name的值，并使用子数组中的索引id作为新索引。

Array
(
    [2135] => Doe
    [3245] => Smith
    [5342] => Jones
    [5623] => Doe
)

array_combine — 创建一个数组，用一个数组的值作为新数组的键名，另一个数组的值作为新数组的值

注意：返回一个数组，要求两个数组的值个数要一样，否则会抛出错误。
array_count_values — 统计数组中所有的值

统计数组中值出现的次数。

返回一个数组：数组的键是 array 里元素值；数组的值是 array 元素值出现的次数。
array_diff — 计算数组的差集

返回在source数组而不在其他数组中的元素值，注意元素比较是先转换成字符（string）再进行全等===比较，所以该函数支持一维数组：
```
$source = [1, 2, 3, 4,5,6];
$filter1 = [3, 4,];
$filter2 = [5, "6"];
$result = array_diff($source, $filter1,$filter2);
print_r($result);
```
```
  
Array
(
    [0] => 1
    [1] => 2
)
```
注意：支持多个数组计算差集。值检查数据值。
array_diff_key — 使用键名比较计算数组的差集

根据 array1 中的键名和 array2 进行比较，返回不同键名的项。本函数和 array_diff() 相同只除了比较是根据键名而不是值来进行的。

注意：同样是先转换成string后再全等比较key名，而且只支持一维数组。支持多个数组计算差集。
array_diff_ukey — 用回调函数对键名比较计算数组的差集
```
array_diff_ukey( array $array1, array $array2[, array $...], callable $key_compare_func) : array
```
array_diff_ukey() 返回一个数组，该数组包括了所有出现在 array1 中但是未出现在任何其它参数数组中的键名的值。注意关联关系保留不变。本函数和 array_diff_key() 相同，除了key比较规则由第三方函数来处理。

该函数满足用户自定义对两个数组的key比较规则，比如有特殊情况处理，某个相同的key被要求保留在差集中。
```
function key_compare_func($key1, $key2)
{
    if ($key1 == $key2)
        return 0;
    else if ($key1 > $key2)
        return 1;
    else
        return -1;
}

$array1 = ['blue'  => 1, 'red'  => 2, 'green'  => 3, 'purple' => 4];
$array2 = ['green' => 5];
$array3 = ['yellow' => 7, 'cyan'   => 8, 'blue' => 6];

var_dump(array_diff_ukey($array1, $array2,$array3, 'key_compare_func'));
```
注意：key_compare_func函数要求比较两个key值后，返回小于、等于、大于0的整数，分别对应第一个数组的key小于、等于、大于第二个数组的key。
array_diff_assoc — 带索引检查计算数组的差集

如果元组的key和value有一个不一样就会返回到差集中。不再仅仅是比较key或是value。
array_diff_uassoc — 用用户提供的回调函数做索引检查来计算数组的差集

注意：回调函数只检查索引值
array_udiff — 用回调函数比较数据来计算数组的差集

注意：回调函数只检查数据值
array_udiff_assoc — 带索引检查计算数组的差集，用回调函数比较数据
array_udiff_uassoc — 带索引检查计算数组的差集，用回调函数比较数据和索引
array_fill — 用给定的值填充数组

用给定的值填充并创建数组。
```
array_fill( int $start_index, int $num, mixed $value) : array
```
array_fill() 用 value 参数的值将一个数组填充 num 个元素，键名由 start_index 参数指定的开始，一般是大于等于0的整数值。

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

使用参数value 作为值，使用 keys 数组的值作为键来填充一个数组。

$keys = array('foo', 5, 10, 'bar');
$a = array_fill_keys($keys, 'banana');
print_r($a);

Array
(
    [foo] => banana
    [5] => banana
    [10] => banana
    [bar] => banana
)

array_filter — 用回调函数过滤数组中的元素
```
array_filter( array $array[, callable $callback[, int $flag = 0]] ) : array
```
依次将 array 数组中的每个值传递到 callback 函数。如果 callback 函数返回 true，则 array 数组的当前值会被包含在返回的结果数组中。数组的键名保留不变。

注意：如果没有提供 callback 函数，将删除 array 中所有等值为 FALSE 的条目，即空字符串、null、0、false等false值都会被删除。
```
$entry = array(
         0 => 'foo',
         1 => false,
         2 => -1,
         3 => null,
        4 => ''
    );

print_r(array_filter($entry));
```
```
Array
(
    [0] => foo
    [2] => -1
)
```
注意：第三个参数flag默认是标记传递给callback是元素值value，也可以指定ARRAY_FILTER_USE_KEY或ARRAY_FILTER_USE_BOTH来传递key或同时传递key与value。
array_flip — 交换数组中的键和值

array_flip() 返回一个反转后的 array，例如 array 中的键名变成了值，而 array 中的值成了键名。

注意 array 中的值需要能够作为合法的键名（例如需要是 int 或者 string）。如果类型不对，将出现一个警告，并且有问题的键／值对将不会出现在结果里。

如果同一个值出现多次，则最后一个键名将作为它的值，其它键会被丢弃。
array_intersect — 计算数组的交集

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

与array_diff原理相似。
array_intersect_key — 使用键名比较计算数组的交集
array_intersect_ukey — 用回调函数比较键名来计算数组的交集
array_intersect_assoc — 带索引检查计算数组的交集

比较准确的检查key和value，并得到交集
array_intersect_uassoc — 带索引检查计算数组的交集，用回调函数比较索引
array_uintersect — 计算数组的交集，用回调函数比较数据
array_uintersect_assoc — 带索引检查计算数组的交集，用回调函数比较数据
array_uintersect_uassoc — 带索引检查计算数组的交集，用单独的回调函数比较数据和索引
array_key_exists — 检查数组里是否有指定的键名或索引

注意：array_key_exists() 仅仅搜索第一维的键。多维数组里嵌套的键不会被搜索到。
array_key_first — 获取指定数组的第一个键值

获取数组中的第一个元素的key。

注意：php7.3开始支持
array_key_last — 获取一个数组的最后一个键值

获取数组中的最后一个元素的key。

注意：php7.3开始支持
array_keys — 返回数组中部分的或所有的键名
```
array_keys( array $array[, mixed $search_value = null[, bool $strict = false]] ) : array
```
array_keys() 返回 input 数组中的数字或者字符串的键名。在7.3之前获取第一个或最后一个元素的key时，通常我们使用array_keys后再进行获取。

注意：如果指定了可选参数 search_value，则只返回该值的键名。否则 input 数组中的所有键名都会被返回。这个功能通常被我们忘记，这就是我们一直想要的通过value查找key的功能。
array_map — 为数组的每个元素应用回调函数
```
array_map( callable $callback, array $array, array ...$arrays) : array
```
这是一个万能数组函数。返回数组，是为 array 每个元素应用 callback函数之后的数组。

array_map() 返回一个 array，数组内容为 array1 的元素按索引顺序为参数调用 callback 后的结果（有更多数组时，还会传入 arrays 的元素）。 callback 函数形参的数量必须匹配 array_map() 实参中数组的数量。也就是说array_map中传入n个数组，则在callback中就会有n个参数，分别对应n个数组中每个数组的元素值，不考虑key。

callback返回的值将作为新数组的元素值，新数组的key根据传入数组的数量不同而不同，如果只有输入一个数组则保留原有key，如果多个数组时，则采用新的整数key值。
array_merge — 合并一个或多个数组
```
array_merge([ array $...] ) : array
```
将一个或多个数组的元素合并起来，一个数组中的值附加在前一个数组的后面。返回作为结果的数组。

如果输入的数组中有相同的字符串键名，则该键名后面的值将覆盖前一个值。然而，如果数组包含数字键名，后面的值将不会覆盖原来的值，而是附加到后面。

如果输入的数组存在以数字作为索引的内容，则这项内容的键名会以连续方式重新索引。如果像覆盖后面相同数字索引的内容，可以使用 + 号，array1 + array2来实现两个数组的合并，但同时覆盖相同的数字索引元素。

也就是说 + 号比起array_merrge的合并更为严格。
```
$array1 = array(0 => 'zero_a', 2 => 'two_a', 3 => 'three_a',"a"=>"apple");
$array2 = array(1 => 'one_b', 3 => 'three_b', 4 => 'four_b',"a"=>"app");
$result = $array1 + $array2;
//$result = array_merge($array1,$array2);
var_dump($result);
```
```
array(6) {
    [0]=>
    string(6) "zero_a"
    [2]=>
    string(5) "two_a"
    [3]=>
    string(7) "three_a"
    ["a"]=>
    string(5) "apple"
    [1]=>
    string(5) "one_b"
    [4]=>
    string(6) "four_b"
}
```
array_merge_recursive — 递归地合并一个或多个数组

array_merge_recursive() 将一个或多个数组的元素合并起来，一个数组中的值附加在前一个数组的后面。返回作为结果的数组。

如果输入的数组中有相同的字符串键名，则这些值会被合并到一个数组中去，这将递归下去，因此如果一个值本身是一个数组，本函数将按照相应的条目把它合并为另一个数组。注意这里，不是覆盖，而是合并到一个数组中去，但和array_merge的理解不大一样。

注意：如果你想使用这个函数，建议不要从array_merge_recursice字面上来理解，一定要去看下官方文档的例子，理解之后才去应用到自己的业务逻辑中。

同时注意的是：如果数组具有相同的数值键名，后一个值将不会覆盖原来的值，而是附加到后面。
```
$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
)
```
array_multisort — 对多个数组或多维数组进行排序

这个函数一开始是很不好理解的。特别是他的参数很灵活多变，可有可无。排序是按字典顺序排列的，官方这句话很不好理解，需要借助例子。
```
array_multisort( array &$array1[, mixed $array1_sort_order = SORT_ASC[, mixed $array1_sort_flags = SORT_REGULAR[, mixed $...]]] ) : bool
```
先看个例子：
```
$arr = [
    ["10", 11, 100, 100, "a"],
    [4,5,2,3,1]
];
array_multisort($arr[0], SORT_ASC, SORT_NUMERIC,
                $arr[1], SORT_NUMERIC, SORT_DESC);
print_r($arr);
```
```
Array
(
    [0] => Array
        (
            [0] => a
            [1] => 10
            [2] => 11
            [3] => 100
            [4] => 100
        )

    [1] => Array
        (
            [0] => 1
            [1] => 4
            [2] => 5
            [3] => 3
            [4] => 2
        )

)
```
array_multi_sort类似于sql语句的order by排序，一列值就是一个一维数组，上例中，$arr[0]先按数字升序排序，$arr[1]在$arr[0]的排序基础上，根据$arr[0]中值相同所在的字典key位置，对应$arr[1]所在字典key位置的值进行数字降序排序。

比如上例，由于有两个100，key分别是2和3，对应$arr[1]中key为2和3值为2和3，进行数字降序后就是我们最终看到的输出结果。

注意：多个数组排序，要保证多个数组的元素个数是一致的。一般多个数组来源于一个多维数组的不同key下的值（数组）。

关于该函数的更多参数解释，详细看官方文档：PHP: array_multisort - Manual
array_pad — 以指定长度将一个值填充进数组

array_pad() 返回 array 的一个拷贝，并用 value 将其填补到 size 指定的长度。如果 size 为正，则填补到数组的右侧，如果为负则从左侧开始填补。如果 size 的绝对值小于或等于 array 数组的长度则没有任何填补。

注意：返回的是一个拷贝，而不是数组本身也不是引用，也就是说是返回的数组不影响原数组。

注意：size就是新数组的长度。
array_pop — 弹出数组最后一个元素（出栈）

array_pop() 弹出并返回 array 数组的最后一个元素，并将数组 array 的长度减一。
array_product — 计算数组中所有值的乘积

array_product() 以整数或浮点数返回一个数组中所有值的乘积。
array_push — 将一个或多个元素压入数组的末尾（入栈）

注意：array_push支持一次压入多个元素

注意：如果用 array_push() 来给数组增加一个元素，还不如用 $array[] = $value，因为这样没有调用函数的额外负担。
array_rand — 从数组中随机取出一个或多个元素
```
array_rand( array $array[, int $num = 1] ) : mixed
```
如果只取出一个，array_rand() 返回随机元素的键名。否则就返回包含随机键名的数组。
array_reduce — 用回调函数迭代地将数组简化为单一的值
```
array_reduce( array $array, callable $callback[, mixed $initial = NULL] ) : mixed
```
array_reduce() 将回调函数 callback 迭代地作用到 array 数组中的每一个元素中，从而将数组简化为单一的值。

不同于array_map数组应用函数，array_reduce的callback允许携带上一次迭代的值进入下一次迭代，最终简化返回一个简单的类型值（非复合类型）
- array
  
  输入的 array。
- callback
  
  callback( mixed $carry, mixed $item) : mixed
  - carry
    
    携带上次迭代里的值；如果本次迭代是第一次，那么这个值是 initial。
  - item
    
    携带了本次迭代的值。
- initial
  
  如果指定了可选参数 initial，该参数将在处理开始前使用，或者当处理结束，数组为空时的最后一个结果。
```
function product($carry, $item)
{
    $carry *= $item;
    return $carry;
}

$a = array(1, 2, 3, 4, 5);

var_dump(array_reduce($a, "product", 10)); // int(1200), = 初始值10**1*2*3*4*5
  
```
array_replace — 使用传递的数组替换第一个数组的元素

array_replace() 函数使用后面数组元素相同 key 的值替换 array 数组的值。
- 如果一个键存在于第一个数组同时也存在于第二个数组，它的值将被第二个数组中的值替换。
- 如果一个键存在于第二个数组，但是不存在于第一个数组，则会在第一个数组中创建这个元素。
- 如果一个键仅存在于第一个数组，它将保持不变。
- 如果传递了多个替换数组，它们将被按顺序依次处理，后面的数组将覆盖之前的值。
- array_replace() 是非递归的：它将第一个数组的值进行替换而不管第二个数组中是什么类型。
```
array_replace( array $array[, array $replacements] ) : array
```
array_replace_recursive — 使用传递的数组递归替换第一个数组的元素
```
array_replace_recursive( array $array1[, array $...] ) : array
```
array_replace_recursive() 使用后面数组元素的值替换数组 array1 的值。
- 如果一个键存在于第一个数组同时也存在于第二个数组，它的值将被第二个数组中的值替换。
- 如果一个键存在于第二个数组，但是不存在于第一个数组，则会在第一个数组中创建这个元素。
- 如果一个键仅存在于第一个数组，它将保持不变。
- 如果传递了多个替换数组，它们将被按顺序依次处理，后面的数组将覆盖之前的值。
- 另外array_replace_recursive() 是递归的：它将遍历数组并将相同的处理应用到数组的内部值。
  
  如果第一个数组中的值是标量，它的值将被第二个数组中的值替换，它可能是一个标量或者数组。如果第一个数组和第二个数组中的值都是数组，array_replace_recursive() 函数将递归地替换它们各自的值。
```
$base = array('citrus' => array( "orange") , 'berries' => array("blackberry", "raspberry"), );
$replacements = array('citrus' => array('pineapple'), 'berries' => array('blueberry'));

$basket = array_replace_recursive($base, $replacements);
print_r($basket);

$basket = array_replace($base, $replacements);
print_r($basket);
```
```
Array
(
    [citrus] => Array
        (
            [0] => pineapple
        )

    [berries] => Array
        (
            [0] => blueberry
            [1] => raspberry
        )

)
Array
(
    [citrus] => Array
        (
            [0] => pineapple
        )

    [berries] => Array
        (
            [0] => blueberry
        )

)
```
array_reverse — 返回元素顺序相反的数组

接受数组 array 作为输入并返回一个元素为相反顺序的新数组。
array_search — 在数组中搜索给定的值，如果成功则返回首个相应的键名
```
array_search( mixed $needle, array $haystack[, bool $strict = false] ) : mixed
```
官方的解释：大海捞针，在大海（haystack）中搜索针（ needle 参数）。

如果找到了 needle 则返回它的键，否则返回 FALSE。

注意：如果 needle 在 haystack 中出现不止一次，则返回第一个匹配的键。要返回所有匹配值的键，应该用 array_keys() 加上可选参数 search_value 来代替。

注意：此函数可能返回布尔值 FALSE，但也可能返回等同于 FALSE 的非布尔值
array_shift — 将数组开头的元素移出数组

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

注意：数字键名的reset。
array_slice — 从数组中取出一段
```
array_slice( array $array, int $offset[, int $length = NULL[, bool $preserve_keys = FALSE]] ) : array
```
array_slice() 返回根据 offset 和 length 参数所指定的 array 数组中的一段序列。

如果 offset 为负，则序列将从 array 中距离末端这么远的地方开始。

注意：array_slice() 默认会重新排序并重置数组的数字索引。你可以通过将 preserve_keys 设为 TRUE 来改变此行为。无论本参数如何设置，都会保留字符串的键。
array_splice — 去掉数组中的某一部分并用其它值取代

把 input 数组中由 offset 和 length 指定的元素去掉，如果提供了 replacement 参数，则用其中的元素取代。
```
array_splice( array &$input, int $offset[, int $length = count($input)[, mixed $replacement = array()]] ) : array
```
虽然replacement是mixed，但建议确保一定是数组。避免带来不必要的麻烦。

注意：&$input是个引用，这是php函数又一个让我们吐槽的地方，有些函数是输入数组不是引用，而是返回一个拷贝数组，而有些函数是引用输入数组，导致记忆混乱，必须要有php手册伴随身边，或者IDE有足够语法自动补充。
```
$input = array("red", "green", "blue", "yellow");
//array_splice($input, 2);
array_splice($input, 2,count($input),['b','y']);
var_dump($input);
```
```
array(4) {
    [0]=>
    string(3) "red"
    [1]=>
    string(5) "green"
    [2]=>
    string(1) "b"
    [3]=>
    string(1) "y"
}
```
array_sum — 对数组中所有值求和

同array_product求数组乘积
array_unique — 移除数组中重复的值

看名字我们就知道是去重，但需要注意的是：

键名保留不变。而且array_unique() 会先将值作为字符串排序，然后对每个值只保留第一个遇到的键名，接着忽略所有后面的键名。所以未排序的数组中同一个值的第一个出现的键名不一定会被保留。
array_unshift — 在数组开头插入一个或多个元素

还有更多相关函数：array_pop、array_push、array_shift
array_values — 返回数组中所有的值

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

类似于array_map，但array_map会返回形成新的数组，而array_walk当下就处理元素了，没有返回新的数组或数据。
```
array_walk( array &$array, callable $callback[, mixed $userdata = NULL] ) : bool
```
通常情况下 callback 接受两个参数。array 参数的值作为第一个，键名作为第二个。

如果提供了可选参数 userdata，将被作为第三个参数传递给 callback 函数。
```
$fruits = array("d" => "lemon", "a" => "orange", "b" => "banana", "c" => "apple");

function test_print($item2, $key,$prefix='')
{
    echo $prefix."_$key: $item2\n";
}

array_walk($fruits, 'test_print', 'fruit');
echo "... and more.\n";
```
```
fruit_d: lemon
fruit_a: orange
fruit_b: banana
fruit_c: apple
... and more.
```
array_walk_recursive — 对数组中的每个成员递归地应用用户函数

将用户自定义函数 callback 应用到 array 数组中的每个元素。本函数会递归到更深层的数组中去。

递归到更深层：始终获得一个key和value传入回调函数中处理。不论元素在多维数组中的哪一维。

注意：任何值为 array 的键都不会被传递到回调函数中去。其他与array_walk函数一样。
array — 新建一个数组
sort — 对数组排序
```
sort( array &$array[, int $sort_flags = SORT_REGULAR] ) : bool
```
注意：排序比较的是值。

注意：$array是引用，也就是直接修改了原数组。

注意：如果两个成员值完全相同，那么它们在排序数组中的相对顺序是未定义的，也就是说没有对下相同的值再次进行排序，可能就是随机的。

注意：此函数为 array 中的元素赋与新的数值键名。这将删除原有的键名，而不是仅仅将键名重新排序。

可选的第二个参数 sort_flags 可以用以下值改变排序的行为：

排序类型标记：
- SORT_REGULAR - 正常比较元素详细描述参见比较运算符章节
- SORT_NUMERIC - 元素被作为数字来比较
- SORT_STRING - 元素被作为字符串来比较
- SORT_LOCALE_STRING - 根据当前的区域（locale）设置来把元素当作字符串比较，可以用 setlocale() 来改变。
- SORT_NATURAL - 和 natsort() 类似对每个元素以"自然的顺序"对字符串进行排序。
- SORT_FLAG_CASE - 能够与 SORT_STRING 或 SORT_NATURAL 合并（OR 位运算），不区分大小写排序字符串。
数组的相关排序函数中关于sort_flags都可以参考这些排序类型标记，包括array_mutilsort。

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

本函数实现了一个和人们通常对字母数字字符串进行排序的方法一样的排序算法并保持原有键／值的关联，这被称为"自然排序”。

sort()排序结果：
Array
(
    [3] => img1.png
    [1] => img10.png
    [0] => img12.png
    [2] => img2.png
)
natsort()排序结果：
Array
(
    [3] => img1.png
    [2] => img2.png
    [1] => img10.png
    [0] => img12.png
)

natcasesort — 用“自然排序”算法对数组进行不区分大小写字母的排序
rsort — 对数组逆向排序
asort — 对数组进行排序并保持索引关系
arsort — 对数组进行逆向排序并保持索引关系
usort — 使用用户自定义的比较函数对数组中的值进行排序
```
usort( array &$array, callable $value_compare_func) : bool
```
本函数将用用户自定义的比较函数对一个数组中的值进行排序。如果要排序的数组需要用一种不寻常的标准进行排序，那么应该使用此函数。

回调函数中在第一个参数小于，等于或大于第二个参数时，该比较函数必须相应地返回一个小于，等于或大于 0 的整数。
uasort — 使用用户自定义的比较函数对数组中的值进行排序并保持索引关联
uksort — 使用用户自定义的比较函数对数组中的键名进行排序
ksort — 对数组按照键名排序
krsort — 对数组按照键名逆向排序
compact — 建立一个数组，包括变量名和它们的值
count — 计算数组中的元素数目，或对象中的属性个数

注意：除了可以统计数组外，还可以统计对象。

count函数有第二个可选参数mode，如果 mode 参数设为 COUNT_RECURSIVE（或 1），count() 将递归地对数组计数。

current — 返回数组中的当前元素

每个数组中都有一个内部的指针指向它"当前的"元素，初始指向插入到数组中的第一个元素。

如果内部指针指向超出了元素列表的末端，current() 返回 FALSE。

$transport = array('foot', 'bike', 'car', 'plane');
echo current($transport),"\n"; // echo 'foot';
echo next($transport),"\n";    // echo 'bike';
echo current($transport),"\n"; // echo 'bike';
echo prev($transport),"\n";    // echo 'foot';
echo end($transport),"\n";     // echo 'plane';
echo current($transport),"\n"; // echo 'plane';

$arr = array();
var_dump(current($arr)); // bool(false)

$arr = array(array());
var_dump(current($arr)); // array(0) { }

each — 返回数组中当前的键／值对并将数组指针向前移动一步

注意：函数已自 PHP 7.2.0 起废弃。强烈建议不要使用本函数。
end — 将数组的内部指针指向最后一个元素

end() 将 array 的内部指针移动到最后一个元素并返回其值。
extract — 从数组中将变量导入到当前的符号表

我们不是很建议使用extract和compact函数。
in_array — 检查数组中是否存在某个值
```
in_array( mixed $needle, array $haystack[, bool $strict = FALSE] ) : bool
```
大海捞针，在大海（haystack）中搜索针（ needle），如果没有设置 strict 则使用宽松的比较。如果找到 needle 则返回 TRUE，否则返回 FALSE。

array_search() - 在数组中通过搜索给定的值，如果成功则返回首个相应的键名

array_key_exists() - 检查数组里是否有指定的键名或索引
key_exists — 别名 array_key_exists
key — 从关联数组中取得键名

key() 返回数组中当前元素的键名。

current() 返回数组中当前元素的值。

list — 把数组中的值赋给一组变量

list( mixed $var[, mixed ...$vars] ) : array

像 array() 一样，这不是真正的函数，而是语言结构。 list() 可以在单次操作内就为一组变量赋值。

$info = array('coffee', 'brown', 'caffeine');

// 列出所有变量
list($drink, $color, $power) = $info;

// 或者让我们跳到仅第三个
list( , , $power) = $info;

// list() 不能对字符串起作用
list($bar) = "abcde";
var_dump($bar); // NULL

next — 将数组中的内部指针向前移动一位
pos — current 的别名
prev — 将数组的内部指针倒回一位

range — 根据范围创建数组，包含指定的元素

range( mixed $start, mixed $end[, int|float $step = 1] ) : array

start和end支持单个字符和整数。

print_r(range(11, 5));

print_r(range("f","k"));


Array
(
    [0] => 11
    [1] => 10
    [2] => 9
    [3] => 8
    [4] => 7
    [5] => 6
    [6] => 5
)
Array
(
    [0] => f
    [1] => g
    [2] => h
    [3] => i
    [4] => j
    [5] => k
)

reset — 将数组的内部指针指向第一个元素

reset() 将 array 的内部指针倒回到第一个元素并返回第一个数组元素的值。
shuffle — 打乱数组

本函数打乱（随机排列元素的顺序）一个数组。
```
shuffle( array &$array) : bool
```
注意：返回true或false，传入array是数组引用。
sizeof — count 的别名

PHP函数参考25-常用数组函数

TsingChan