如何在PHP中对数组进行递归合并？array_replace_recursive()用法

array_replace_recursive() 是 PHP 中用于递归合并数组的核心函数，尤其适用于配置覆盖场景。它按字符串键进行深度替换：若相同键对应数组则递归合并，非数组则直接替换；对数字键则按索引替换而非追加，不会重新索引。与 array_merge_recursive() 不同，后者会将同键值（包括非数组）合并为新数组，导致意外嵌套，而前者更符合“覆盖”语义。需注意其对数字键的替换行为可能导致数据被意外覆盖，不适用于需保留所有元素的场景。

在PHP中对数组进行递归合并，最直接且常用的方法就是使用

array_replace_recursive()

解决方案

array_replace_recursive()

array_replace_recursive(array $array1, array ...$arrays): array

让我来详细解释一下它的工作机制和一些我个人在使用中发现的“小脾气”：

1. 字符串键的替换与合并： 当遇到字符串键时，如果键在多个数组中都存在，那么右边数组（后传入的数组）的值会替换掉左边数组（先传入的数组）中相同键的值。如果两个相同键的值都是数组，那么它会递归地进入这两个子数组，继续进行替换合并。这非常符合我们常说的“配置覆盖”场景。

   立即学习“PHP免费学习笔记（深入）”；

2. 数字键的“替换”行为： 这是最容易让人产生误解的地方。

   array_replace_recursive()

   登录后复制
   对于数字键的处理方式，与它处理字符串键的方式有所不同。它不会像

   array_merge()

   登录后复制
   那样简单地重新索引或追加数字键的值。相反，它会尝试按索引进行替换。这意味着如果

   $arr1

   登录后复制
   有一个

   0

   登录后复制
   键，

   $arr2

   登录后复制
   也有一个

   0

   登录后复制
   键，那么

   $arr2[0]

   登录后复制
   会直接替换

   $arr1[0]

   登录后复制
   ，即使它们都是数组，它也不会像字符串键那样进行深度合并。如果

   $arr2

   登录后复制
   有一个

   $key

   登录后复制
   而

   $arr1

   登录后复制
   没有，那么这个

   $key

   登录后复制
   会被添加到

   $arr1

   登录后复制
   中。如果

   $arr1

   登录后复制
   有一个

   $key

   登录后复制
   而

   $arr2

   登录后复制
   没有，那么

   $arr1[$key]

   登录后复制
   会保持不变。

3. 非数组值与数组值的替换： 如果在合并过程中，一个键在某个数组中对应的是一个非数组值（比如字符串、整数），而在另一个数组中对应的是一个数组，那么非数组值会被直接替换成数组。反之亦然。它不会尝试将非数组值“塞进”数组，或将数组“扁平化”成非数组。

来看一个具体的例子，这样可能更直观：

<?php

$defaults = [
    'app_name' => 'My Application',
    'debug_mode' => false,
    'database' => [
        'host' => 'localhost',
        'port' => 3306,
        'username' => 'root',
        'password' => '',
        'options' => [
            'charset' => 'utf8mb4',
            'persistent' => false
        ]
    ],
    'features' => [
        'user_registration' => true,
        'email_verification' => false,
        0 => 'feature_a' // 这是一个数字键
    ]
];

$user_config = [
    'debug_mode' => true, // 覆盖 debug_mode
    'database' => [
        'host' => '192.168.1.100', // 覆盖 host
        'password' => 'mysecret', // 覆盖 password
        'options' => [
            'persistent' => true, // 覆盖 persistent
            'timeout' => 5 // 新增 timeout
        ]
    ],
    'features' => [
        'email_verification' => true, // 覆盖 email_verification
        1 => 'feature_b' // 新增数字键 1
    ],
    'new_setting' => 'some_value' // 新增顶级设置
];

$merged_config = array_replace_recursive($defaults, $user_config);

echo '<pre>';
print_r($merged_config);
echo '</pre>';

/*
输出结果大致如下：
Array
(
    [app_name] => My Application
    [debug_mode] => 1 // true 被转换为 1
    [database] => Array
        (
            [host] => 192.168.1.100
            [port] => 3306
            [username] => root
            [password] => mysecret
            [options] => Array
                (
                    [charset] => utf8mb4
                    [persistent] => 1 // true 被转换为 1
                    [timeout] => 5
                )
        )
    [features] => Array
        (
            [user_registration] => 1
            [email_verification] => 1
            [0] => feature_a // 这里的数字键 0 保持不变，因为 user_config 没有覆盖它
            [1] => feature_b // user_config 中的数字键 1 被添加进来
        )
    [new_setting] => some_value
)
*/

// 再看一个数字键替换的例子
$arr_base = ['a', 'b', 'c'];
$arr_override = [0 => 'x', 2 => 'y', 3 => 'z']; // 覆盖索引 0, 2，新增索引 3

$result_numeric = array_replace_recursive($arr_base, $arr_override);
echo '<pre>';
print_r($result_numeric);
echo '</pre>';

/*
输出结果：
Array
(
    [0] => x
    [1] => b
    [2] => y
    [3] => z
)
*/
// 可以看到，索引 0 和 2 的值被替换，索引 1 的值保持不变，索引 3 的值被添加。
// 这里的行为更像是 "按索引替换"，而不是 "追加并重新索引"。

?>

array_merge_recursive()

登录后复制

与

array_replace_recursive()

登录后复制

有何不同？

这是一个非常经典的问题，也是很多PHP开发者初次接触数组合并时容易混淆的地方。理解它们之间的核心差异至关重要，因为它们在某些情况下会导致截然不同的结果。

标书对比王

标书对比王是一款标书查重工具，支持多份投标文件两两相互比对，重复内容高亮标记，可快速定位重复内容原文所在位置，并可导出比对报告。

58

查看详情

在我看来，最本质的区别在于：

array_merge_recursive()

array_replace_recursive()

1. array_merge_recursive()

   登录后复制
   的行为：
   • 字符串键： 如果两个数组中有相同的字符串键，并且它们的值都是数组，那么

     array_merge_recursive()

     登录后复制
     会递归地合并这些子数组。但如果其中一个或两个值不是数组，它会将所有相同键的值放入一个新的数组中。这通常会导致意想不到的多层嵌套数组，比如

     ['key' => [value1, value2]]

     登录后复制
     。
   • 数字键： 对于数字键，

     array_merge_recursive()

     登录后复制
     的行为更像是

     array_merge()

     登录后复制
     。它会简单地将所有数字键的值追加到结果数组的末尾，并重新建立从

     0

     登录后复制
     开始的连续索引。这意味着它会保留所有数字键的值，而不是替换它们。

   让我们看个例子：

   <?php
   $arr1 = [
       'config' => ['a' => 1, 'b' => 2],
       'items' => ['item1', 'item2'],
       'data' => 'initial'
   ];
   $arr2 = [
       'config' => ['b' => 3, 'c' => 4],
       'items' => ['item3'],
       'data' => 'updated'
   ];
   
   $merged_recursive = array_merge_recursive($arr1, $arr2);
   echo '<pre>';
   echo 'array_merge_recursive 结果：' . PHP_EOL;
   print_r($merged_recursive);
   echo '</pre>';
   
   /*
   输出：
   array_merge_recursive 结果：
   Array
   (
       [config] => Array
           (
               [a] => 1
               [b] => 3 // 'b' 被覆盖
               [c] => 4
           )
       [items] => Array // 注意这里，'items' 变成了嵌套数组
           (
               [0] => item1
               [1] => item2
               [2] => item3
           )
       [data] => Array // 'data' 也变成了嵌套数组
           (
               [0] => initial
               [1] => updated
           )
   )
   */
   ?>

   登录后复制

   从上面的例子可以看出，

   array_merge_recursive()

   登录后复制
   在

   items

   登录后复制
   和

   data

   登录后复制
   键上，将原始值和新值都保留了下来，并放入了一个新的数组中。这在配置合并的场景中，通常不是我们想要的行为。

2. array_replace_recursive()

   登录后复制
   的行为：
   • 字符串键： 如前所述，它会递归地替换相同字符串键的值。如果都是数组，则递归合并；如果不是，则直接替换。这使得它非常适合配置覆盖。
   • 数字键： 它不会重新索引。它会尝试按现有索引进行替换。如果一个数字键在源数组中不存在，它会被添加。如果存在，则值会被替换。

   再用同样的例子对比

   array_replace_recursive()

   登录后复制
   ：

   <?php
   $arr1 = [
       'config' => ['a' => 1, 'b' => 2],
       'items' => ['item1', 'item2'],
       'data' => 'initial'
   ];
   $arr2 = [
       'config' => ['b' => 3, 'c' => 4],
       'items' => ['item3'],
       'data' => 'updated'
   ];
   
   $replace_recursive = array_replace_recursive($arr1, $arr2);
   echo '<pre>';
   echo 'array_replace_recursive 结果：' . PHP_EOL;
   print_r($replace_recursive);
   echo '</pre>';
   
   /*
   输出：
   array_replace_recursive 结果：
   Array
   (
       [config] => Array
           (
               [a] => 1
               [b] => 3
               [c] => 4
           )
       [items] => Array
           (
               [0] => item3 // 'item1' 被 'item3' 替换，'item2' 保持不变
               [1] => item2
           )
       [data] => updated // 'initial' 被 'updated' 替换
   )
   */
   ?>

   登录后复制

   可以看到，

   array_replace_recursive()

   登录后复制
   的结果更符合我们通常理解的“覆盖”和“合并”：

   data

   登录后复制
   键的值被直接替换，

   items

   登录后复制
   数组的第一个元素被替换，而第二个元素保持不变。

总结一下： 如果你想要的是一个深度合并，其中新值（包括数组）会替换掉旧值，那么

array_replace_recursive()

array_merge_recursive()

array_merge_recursive()

array_replace_recursive()

登录后复制

有哪些局限性或需要注意的边缘情况？

虽然

array_replace_recursive()

1. 数字键的“替换”而非“智能合并”： 这是我前面强调过的，也是最常见的误解。如果你的数组中包含大量数字键（比如一个对象列表，每个对象都有一个唯一的ID，但你把它放在了数字索引的数组中），

   array_replace_recursive()

   登录后复制
   会尝试按索引替换，而不是根据某个内部的ID进行智能合并。这意味着如果你有两个

   [0 => ['id' => 1, 'name' => 'A']]

   登录后复制
   和

   [0 => ['id' => 2, 'name' => 'B']]

   登录后复制
   ，结果会是

   [0 => ['id' => 2, 'name' => 'B']]

   登录后复制
   ，而不是保留两个或根据ID合并。如果你需要根据特定字段（如

   id

   登录后复制
   ）来合并数组中的对象，`array

以上就是如何在PHP中对数组进行递归合并？array_replace_recursive()用法的详细内容，更多请关注php中文网其它相关文章！