数组函数

    另请参阅

    另请参阅 is_array()，explode()，implode()，preg_split() 和 unset()。

    目录

    • array — 创建数组
    • array_change_key_case — 更改数组中所有键的大小写
    • array_chunk — 将数组分割成块
    • array_column — 返回输入数组中单个列的值
    • array_combine — 使用一个数组作为键，另一个数组作为值创建数组
    • array_count_values — 计算数组中每个不同值的出现次数
    • array_diff — 计算数组的差集
    • array_diff_assoc — 计算数组的差集，并进行额外的索引检查
    • array_diff_key — 使用键进行比较来计算数组的差集
    • array_diff_uassoc — 计算数组的差集，并进行额外的索引检查，该检查由用户提供的回调函数执行
    • array_diff_ukey — 使用回调函数对键进行比较来计算数组的差集
    • array_fill — 用值填充数组
    • array_fill_keys — 用值填充数组，指定键
    • array_filter — 使用回调函数过滤数组的元素
    • array_flip — 交换数组中所有键与其关联的值
    • array_intersect — 计算数组的交集
    • array_intersect_assoc — 计算数组的交集，并进行额外的索引检查
    • array_intersect_key — 使用键进行比较来计算数组的交集
    • array_intersect_uassoc — 计算数组的交集，并进行额外的索引检查，通过回调函数比较索引
    • array_intersect_ukey — 使用回调函数对键进行比较来计算数组的交集
    • array_is_list — 检查给定数组是否为列表
    • array_key_exists — 检查给定键或索引是否存在于数组中
    • array_key_first — 获取数组的第一个键
    • array_key_last — 获取数组的最后一个键
    • array_keys — 返回数组的所有键或键的子集
    • array_map — 将回调函数应用于给定数组的元素
    • array_merge — 合并一个或多个数组
    • array_merge_recursive — 递归地合并一个或多个数组
    • array_multisort — 对多个或多维数组进行排序
    • array_pad — 用值将数组填充到指定长度
    • array_pop — 从数组末尾弹出元素
    • array_product — 计算数组中值的乘积
    • array_push — 将一个或多个元素推送到数组末尾
    • array_rand — 从数组中随机选取一个或多个键
    • array_reduce — 使用回调函数将数组迭代地缩减为单个值
    • array_replace — 将传递的数组中的元素替换到第一个数组中
    • array_replace_recursive — 递归地将传递的数组中的元素替换到第一个数组中
    • array_reverse — 返回元素顺序相反的数组
    • array_search — 在数组中搜索给定值，如果成功则返回第一个对应的键
    • array_shift — 从数组开头移出元素
    • array_slice — 从数组中提取一部分
    • array_splice — 移除数组的一部分并用其他东西替换它
    • array_sum — 计算数组中值的总和
    • array_udiff — 使用回调函数进行数据比较来计算数组的差集
    • array_udiff_assoc — 计算数组的差集，并进行额外的索引检查，通过回调函数比较数据
    • array_udiff_uassoc — 计算数组的差集，并进行额外的索引检查，通过回调函数比较数据和索引
    • array_uintersect — 使用回调函数进行数据比较来计算数组的交集
    • array_uintersect_assoc — 计算数组的交集，并进行额外的索引检查，通过回调函数比较数据
    • array_uintersect_uassoc — 计算数组的交集，并进行额外的索引检查，通过单独的回调函数比较数据和索引
    • array_unique — 从数组中删除重复值
    • array_unshift — 在数组开头添加一个或多个元素
    • array_values — 返回数组的所有值
    • array_walk — 将用户提供的函数应用于数组的每个成员
    • array_walk_recursive — 将用户函数递归地应用于数组的每个成员
    • arsort — 按降序对数组进行排序，并保持索引关联
    • asort — 按升序对数组进行排序，并保持索引关联
    • compact — 创建包含变量及其值的数组
    • count — 计算数组或 Countable 对象中的所有元素
    • current — 返回数组中的当前元素
    • each — 返回数组中的当前键值对，并向前移动数组指针
    • end — 将数组的内部指针设置为最后一个元素
    • extract — 从数组中导入变量到当前符号表
    • in_array — 检查数组中是否存在某个值
    • key — 从数组中获取键
    • key_exists — array_key_exists 的别名
    • krsort — 按降序对数组进行键排序
    • ksort — 按升序对数组进行键排序
    • list — 将变量分配为数组
    • natcasesort — 使用不区分大小写的“自然顺序”算法对数组进行排序
    • natsort — 使用“自然顺序”算法对数组进行排序
    • next — 前移数组的内部指针
    • pos — current 的别名
    • prev — 倒回数组内部指针
    • range — 创建包含一系列元素的数组
    • reset — 将数组的内部指针设置为第一个元素
    • rsort — 按降序对数组进行排序
    • shuffle — 打乱数组
    • sizeof — count 的别名
    • sort — 按升序对数组进行排序
    • uasort — 使用用户定义的比较函数对数组进行排序，并保持索引关联
    • uksort — 使用用户定义的比较函数对数组进行键排序
    • usort — 使用用户定义的比较函数对数组进行值排序

    改进此页面

    了解如何改进此页面 • 提交拉取请求 • 报告错误
    ＋添加注释

    用户贡献的注释 14 个注释

    9
    et2225zas14 at susu dot ru
    3 个月前
    使用数组遍历函数时，请注意回调函数中的类型提示。在某些情况下，这可能会导致元素的数据类型静默地更改。

    <?php
    declare(strict_types=1);

    // 缺少致命 TypeError，无副作用
    $unexpected = array_filter(['123', (string) PHP_INT_MAX], fn (int $item) => true);
    var_dump($unexpected);

    // 缺少致命 TypeError，类型转换副作用
    $unexpectedTypecasting = array_map(fn (int $item) => $item, ['123', (string) PHP_INT_MAX]);
    var_dump($unexpectedTypecasting);

    // 缺少致命 TypeError，类型转换副作用
    $unexpectedTypecasting = array_map(fn (string $item) => $item, [123, PHP_INT_MAX]);
    var_dump($unexpectedTypecasting);

    // 缺少致命 TypeError，类型转换副作用
    $unexpectedTypecasting = array_reduce(['123', (string) PHP_INT_MAX], fn (?int $carry, int $item) => $item);
    var_dump($unexpectedTypecasting);

    $bigIntValue = bcadd((string) PHP_INT_MAX, '1');
    // 致命 TypeError
    $expectedTypeError = array_map(fn (int $item) => $item, [$bigIntValue]);
    var_dump($expectedTypeError);
    ?>

    以上示例将输出（PHP 版本 8.3.6，error_reporting E_ALL）

    <?php
    array(2) {
    [    0]=>
    string(3) "123"
    [1]=>
    string(19) "9223372036854775807"
    }
    array(    2) {
    [    0]=>
    int(123)
    [    1]=>
    int(9223372036854775807)
    }
    array(    2) {
    [    0]=>
    string(3) "123"
    [1]=>
    string(19) "9223372036854775807"
    }
    int(9223372036854775807)

    Fatal error: Uncaught TypeError: {closure}(): Argument #1 ($item) must be of type int, string given
    ?>
    21
    permanovd at gmail dot com
    6 年前
    一个简单的技巧，可以帮助你根据 diff/intersect 或 sort 函数的名称来猜测其功能。

    [后缀] assoc - 额外的索引检查。比较值和索引。

    例如：array_diff_assoc、array_intersect_assoc。

    [后缀] key - 仅索引检查。忽略数组的值，仅比较索引。

    例如：array_diff_key、array_intersect_key。

    [后缀] **empty** - 后缀中没有 “key” 或 “assoc” 字。仅比较值。忽略数组的索引。

    例如：array_diff、array_intersect。

    [前缀] u - 将使用用户定义函数进行比较。字母 u 可以在某些函数中使用两次（例如 array_udiff_uassoc），这意味着你需要使用 2 个函数（一个用于值，一个用于索引）。

    例如：array_udiff_uassoc、array_uintersect_assoc。

    这也适用于数组排序函数

    [前缀] a - 关联。将保留键。

    例如：arsort、asort。

    [前缀] k - 键排序。将按键对数组进行排序。

    例如：uksort、ksort。

    [前缀] r - 反转。将按反序对数组进行排序。

    例如：rsort、krsort。

    [前缀] u - 按用户定义函数排序（与 diff/intersect 相同）。

    例如：usort、uasort。
    3
    renatonascto at gmail dot com
    15 年前
    大型数组会使用大量的内存，可能会导致内存限制错误。你可以在脚本完成后立即销毁它们，从而减少内存使用量。通过简单地销毁不再使用的某些变量，我能够节省几兆字节的内存。
    你可以使用函数 memory_get_usage() 查看内存使用量/增益。希望这有帮助！
    -1
    indioeuropeo at driverop dot com
    5 年前
    我需要从数组中取出一个元素，并通过移动其他元素来改变它在数组中的位置。
    这是执行此操作的函数。第一个参数是工作数组。第二个是移动元素的位置，第三个是移动元素到的位置。
    该函数返回修改后的数组。
    <?php
    function array_move_elem($array, $from, $to) {
    if (    $from == $to) { return $array; }
    $c = count($array);
    if ((    $c > $from) and ($c > $to)) {
    if (    $from < $to) {
    $f = $array[$from];
    for (    $i = $from; $i < $to; $i++) {
    $array[$i] = $array[$i+1];
    }
    $array[$to] = $f;
    } else {
    $f = $array[$from];
    for (    $i = $from; $i > $to; $i--) {
    $array[$i] = $array[$i-1];
    }
    $array[$to] = $f;
    }

    }
    return     $array;
    }

    ?>
    示例
    <?php
    $array     = array('Cero','Uno','Dos','Tres','Cuatro','Cinco','Seis','Siete','Ocho','Nueve','Diez');
    $array = array_move_elem($array, 3, 5); // 将位置 3 的元素移动到位置 5...
    print_r($array);

    $array = array_move_elem($array, 5, 3); // 将位置 5 的元素移动到位置 3，保持数组不变... ;)
    print_r($array);

    ?>
    返回值
    <?php
    Array ( [0] => Cero [1] => Uno [2] => Dos [3] => Cuatro [4] => Cinco [5] => Tres [6] => Seis [7] => Siete [8] => Ocho [9] => Nueve [10] => Diez )
    Array ( [    0] => Cero [1] => Uno [2] => Dos [3] => Tres [4] => Cuatro [5] => Cinco [6] => Seis [7] => Siete [8] => Ocho [9] => Nueve [10] => Diez )
    ?>
    -10
    nicoolasens at gmail dot com
    8 年前
    /*更改索引而不重写整个表并保持在同一位置。
    */
    <?php
    function change_index(&$tableau, $old_key, $new_key) {
    $changed = FALSE;
    $temp = 0;
    foreach (    $tableau as $key => $value) {
    switch (    $changed) {
    case     FALSE :
    // 创建新键并删除旧键
    if ($key == $old_key) {
    $tableau[$new_key] = $tableau[$old_key];
    unset(    $tableau[$old_key]);
    $changed = TRUE;
    }
    break;

    case     TRUE :
    // 移动后续键
    if ($key != $new_key){
    $temp= $tableau[$key];
    unset(    $tableau[$key]);
    $tableau[$key] = $temp;
    break;
    }
    else {    $changed = FALSE;} // 停止
    }
    }
    array_values($tableau); // 释放内存
    }

    // 结果：
    $tableau = array(1, 2 , 3, 4,5, 6, 7, 8, 9, 10);
    $res = print_r($tableau, TRUE);
    $longueur = strlen($res) -1;
    echo     "旧数组：\n" . substr($res, 8, $longueur) . "\n" ;

    change_index ($tableau, 2, 'number 2');
    $res = print_r($tableau, TRUE);
    $longueur = strlen($res) -10;
    echo     "新数组：\n" . substr($res, 8, $longueur) . "\n" ;

    /*
    旧数组：
    [0] => 1
    [1] => 2
    [2] => 3
    [3] => 4
    [4] => 5
    [5] => 6
    [6] => 7
    [7] => 8
    [8] => 9
    [9] => 10
    )

    新数组：
    [0] => 1
    [1] => 2
    [numéro 2] => 3
    [3] => 4
    [4] => 5
    [5] => 6
    [6] => 7
    [7] => 8
    [8] => 9
    [9] => 10
    */
    ?>
    -16
    info at hotkey404 dot com
    3 年前
    更新了 'indioeuropeo' 的代码，增加了输入字符串键的功能。

    输入
    array(4) {
    ["a"]=>
    string(5) "Apple"
    ["b"]=>
    string(6) "Banana"
    ["c"]=>
    string(3) "Cat"
    ["d"]=>
    string(3) "Dog"
    }

    输出
    array(4) {
    ["a"]=>
    string(5) "Apple"
    ["d"]=>
    string(3) "Dog"
    ["b"]=>
    string(6) "Banana"
    ["c"]=>
    string(3) "Cat"
    }

    函数
    <?php
    function array_move_elem($array, $from, $to){
    // 如果非数字找不到或 from=to 则返回
    if(!is_numeric($from)){
    if(    array_search($from, array_keys($array))!==FALSE){
    $from = array_search($from, array_keys($array));
    }else{
    return     $array;
    }
    }
    $array_numeric_keys = array();
    foreach(    $array as $k => $v){
    $array_numeric_keys[] = $k;
    }
    if (    $from == $to) { return $array; }
    $c = count($array_numeric_keys);
    if ((    $c > $from) and ($c > $to)) {
    if (    $from < $to) {
    $f = $array_numeric_keys[$from];
    for (    $i = $from; $i < $to; $i++) {
    $array_numeric_keys[$i] = $array_numeric_keys[$i+1];
    }
    $array_numeric_keys[$to] = $f;
    } else {
    $f = $array_numeric_keys[$from];
    for (    $i = $from; $i > $to; $i--) {
    $array_numeric_keys[$i] = $array_numeric_keys[$i-1];
    }
    $array_numeric_keys[$to] = $f;
    }

    }
    $array_new = array();
    foreach(    $array_numeric_keys as $v){
    $array_new[$v] = $array[$v];
    }
    return     $array_new;
    }
    ?>
    -26
    kolkabes at googlemail dot com
    12 年前
    用于递归复制数组并在过程中克隆对象的简短函数。

    <?php
    function arrayCopy( array $array ) {
    $result = array();
    foreach(     $array as $key => $val ) {
    if(     is_array( $val ) ) {
    $result[$key] = arrayCopy( $val );
    } elseif (     is_object( $val ) ) {
    $result[$key] = clone $val;
    } else {
    $result[$key] = $val;
    }
    }
    return     $result;
    }
    ?>
    -23
    ob at babcom dot biz
    17 年前
    这是一个用于找出多维数组最大深度的函数。

    <?php
    // 返回给定数组的深度
    // 如果数组是字符串数组，ArrayDepth() 将返回 0
    // 用法：int ArrayDepth(array Array)

    function ArrayDepth($Array,$DepthCount=-1,$DepthArray=array()) {
    $DepthCount++;
    if (    is_array($Array))
    foreach (    $Array as $Key => $Value)
    $DepthArray[]=ArrayDepth($Value,$DepthCount);
    else
    return     $DepthCount;
    foreach(    $DepthArray as $Value)
    $Depth=$Value>$Depth?$Value:$Depth;
    return     $Depth;
    }
    ?>
    -27
    dave at davidhbrown dot us
    12 年前
    虽然 PHP 有超过 60 个数组函数，但截至 PHP 5.3，奇怪的是缺少 array_rotate。在网上搜索提供了多种解决方案，但我发现的解决方案存在缺陷，例如低效地循环遍历数组或忽略键。

    以下 array_rotate() 函数使用 array_merge 和 array_shift 来可靠地向前或向后旋转数组，保留键。如果您知道可以信任您的 $array 是数组，并且 $shift 在 0 到数组长度之间，您可以跳过函数定义，并在代码中使用返回值表达式。

    <?php
    function array_rotate($array, $shift) {
    if(!    is_array($array) || !is_numeric($shift)) {
    if(!    is_array($array)) error_log(__FUNCTION__.' expects first argument to be array; '.gettype($array).' received.');
    if(!    is_numeric($shift)) error_log(__FUNCTION__.' expects second argument to be numeric; '.gettype($shift)." `$shift` received.");
    return     $array;
    }
    $shift %= count($array); //we won't try to shift more than one array length
    if($shift < 0) $shift += count($array);//handle negative shifts as positive
    return array_merge(array_slice($array, $shift, NULL, true), array_slice($array, 0, $shift, true));
    }
    ?>
    一些简单的测试
    <?php
    $array    =array("foo"=>1,"bar"=>2,"baz"=>3,4,5);

    print_r(array_rotate($array, 2));
    print_r(array_rotate($array, -2));
    print_r(array_rotate($array, count($array)));
    print_r(array_rotate($array, "4"));
    print_r(array_rotate($array, -9));
    ?>
    -17
    DamianKaelGreen at gmail dot com
    7 年前
    虽然 PHP 库中有很多数组函数，但也似乎缺少很多基本函数。

    我继续创建了几个我自己的函数来处理多个非关联（na）数组，包括

    na_array_merge
    na_array_intersect
    na_array_diff
    na_array_xnor
    na_array_xor

    如果你用维恩图来思考你的数组，那么这些函数可能适合你。

    我已经将它们提供出来，并在以下位置发布了它们的文档： https://www.greendingle.com/some-useful-non-associative-array-functions/
    -25
    Ewan
    7 年前
    我在这里寻找一个数组聚合函数，最后写了这个函数。

    注意：此实现假设你正在聚合的字段都不包含“@”符号。

    <?php
    function array_group_by($flds, $arr) {
    $groups = array();
    foreach (    $arr as $rec) {
    $keys = array_map(function($f) use($rec) { return $rec[$f]; }, $flds);
    $k = implode('@', $keys);
    if (isset(    $groups[$k])) {
    $groups[$k][] = $rec;
    } else {
    $groups[$k] = array($rec);
    }
    }
    return     $groups;
    }

    ?>
    -26
    oliverSPAMMENOT at e-geek dot com dot au
    14 年前
    用于漂亮打印数组和对象的函数。检测对象递归并允许设置最大深度。基于 print_r 函数说明中的 arraytostring 和 u_print_r。应该像这样调用

    <?php
    egvaluetostring    ($value) //没有最大深度，或者
    egvaluetostring($value, $max_depth) //设置最大深度

    function egvaluetostring($value, $max_depth, $key = NULL, $depth = 0, $refChain = array()) {
    if(    $depth > 0)
    $tab = str_repeat("\t", $depth);
    $text .= $tab . ($key !== NULL ? $key . " => " : "");

    if (    is_array($value) || is_object($value)) {
    $recursion = FALSE;
    if (    is_object($value)) {
    foreach (    $refChain as $refVal) {
    if (    $refVal === $value) {
    $recursion = TRUE;
    break;
    }
    }
    array_push($refChain, $value);
    }

    $text .= (is_array($value) ? "array" : "object") . " ( ";

    if (    $recursion) {
    $text .= "*RECURSION* ";
    }
    elseif (isset(    $max_depth) && $depth >= $max_depth) {
    $text .= "*MAX DEPTH REACHED* ";
    }
    else {
    if (!empty(    $value)) {
    $text .= "\n";
    foreach (    $value as $child_key => $child_value) {
    $text .= egvaluetostring($child_value, $max_depth, (is_array($value) ? "[" : "") . $child_key . (is_array($value) ? "]" : ""), $depth+1, $refChain) . ",\n";
    }
    $text .= "\n" . $tab;
    }
    }

    $text .= ")";

    if (    is_object($value)) {
    array_pop($refChain);
    }
    }
    else {
    $text .= "$value";
    }

    return     $text;
    }
    ?>
    -30
    mo dot longman at gmail dot com
    17 年前
    致 2g4wx3
    我认为更好的方法是使用 JSON，如果你在你的 PHP 中有这样的模块。请参阅 json.org。

    将 JS 数组转换为 JSON 字符串：arr.toJSONString();
    将 JSON 字符串转换为 PHP 数组：json_decode($jsonString);

    你也可以将对象、数字等字符串化。
    -29
    cyberchrist at futura dot net
    16 年前
    最近，在处理数据库时，我发现自己需要知道一个数组 $a 是否是 $b 的一个真子集。

    在数学上，这要求（在集合论中）（请原谅使用 u 和 n 而不是正确的 Unicode）

    ( A u B ) n ( ~ B )

    这样做首先将范围限制为已知的值，然后查找不在 B 中但在 A 和 B 的并集中的任何东西（这将是 A 中但不在 B 中的东西）。

    如果此集合中存在任何值，则 A 不是 B 的真子集，因为 A 中存在一个不在 B 中的值。为了使 A 成为真子集，A 中的所有值都必须在 B 中。

    我确信这可以用多种方式轻松完成，但这对我来说似乎有效。它没有很多错误检测，例如对输入进行消毒或检查输入类型。

    // bool array_subset( array, array )
    // 如果 $a 是 $b 的真子集，则返回 true，否则返回 false。

    function array_subset( $a, $b )
    {
    if( count( array_diff( array_merge($a,$b), $b)) == 0 )
    return true;
    else
    return false;
    }
    ＋添加注释
    To Top