当前位置：首页 > 文章列表 > 文章 > php教程 > PHP数组合并技巧：array_merge_recursive详解

PHP数组合并技巧：array_merge_recursive详解

2025-09-15 09:57:47 0浏览收藏

从现在开始，我们要努力学习啦！今天我给大家带来《PHP合并数组方法：array_merge_recursive使用详解》，感兴趣的朋友请继续看下去吧！下文中的内容我们主要会涉及到等等知识点，如果在阅读本文过程中有遇到不清楚的地方，欢迎留言呀！我们一起讨论，一起学习！

array_merge_recursive() 能递归合并多层数组，相同键的值会保留并形成新数组，适用于深度合并配置或嵌套数据，而 array_merge() 会直接覆盖同名键，适合扁平结构合并。

如何在PHP中合并多个数组？array_merge_recursive()的用法解析

在PHP中，合并多个数组是日常开发中非常普遍的需求。当我们面对需要深度合并、尤其是包含多层嵌套数组的场景时，array_merge_recursive()函数就显得尤为重要了。它能确保在合并过程中，即使键名冲突，也不会简单地覆盖掉值，而是尝试将它们都保留下来，形成一个新的数组结构。简单来说，它会递归地遍历所有输入的数组，将相同键名的值进行智能合并。

解决方案

array_merge_recursive() 函数的设计初衷，就是为了解决深层数组合并的痛点。它的工作方式有点像一个“收集器”：

当你传入多个数组给 array_merge_recursive() 时：

对于数值型键（Numeric Keys）：它会把所有同名键的值都追加到结果数组中。这意味着，如果你有 [0 => 'a'] 和 [0 => 'b']，结果会是 [0 => 'a', 1 => 'b']（键会被重新索引）。
对于字符串型键（String Keys）：这是它最特别的地方。
- 如果同名字符串键对应的值都是非数组类型（比如都是字符串、整数），它会把这些值收集到一个新的数组中。例如，['key' => 'value1'] 和 ['key' => 'value2'] 会合并成 ['key' => ['value1', 'value2']]。
- 如果同名字符串键对应的值中，一个是数组，另一个是非数组，非数组的值也会被追加到数组中。例如，['key' => ['value1']] 和 ['key' => 'value2'] 会合并成 ['key' => ['value1', 'value2']]。
- 如果同名字符串键对应的值都是数组，那么它会递归地调用自身来合并这两个子数组。这正是“recursive”的精髓所在。

来看个具体的例子，这样理解起来更直观：

<?php
$array1 = [
    'name' => 'Alice',
    'options' => [
        'color' => 'red',
        'size' => 'M'
    ],
    'tags' => ['PHP', 'Web']
];

$array2 = [
    'name' => 'Bob',
    'options' => [
        'size' => 'L',
        'material' => 'cotton'
    ],
    'tags' => ['CSS', 'Web'],
    'new_field' => 'value'
];

$array3 = [
    'options' => [
        'color' => 'blue',
        'type' => 'hoodie'
    ],
    'tags' => 'JavaScript' // 注意这里是一个字符串，不是数组
];

$mergedArray = array_merge_recursive($array1, $array2, $array3);

print_r($mergedArray);
?>

输出结果会是这样：

Array
(
    [name] => Array
        (
            [0] => Alice
            [1] => Bob
        )

    [options] => Array
        (
            [color] => Array
                (
                    [0] => red
                    [1] => blue
                )

            [size] => Array
                (
                    [0] => M
                    [1] => L
                )

            [material] => cotton
            [type] => hoodie
        )

    [tags] => Array
        (
            [0] => PHP
            [1] => Web
            [2] => CSS
            [3] => Web
            [4] => JavaScript
        )

    [new_field] => value
)

从这个结果能看出来，name 键的值被合并成了一个数组；options 内部的 color 和 size 也被递归合并成了数组，而 material 和 type 则直接添加了进来；tags 键更是把所有值，包括那个单独的字符串 'JavaScript' 都收集到了一个数组里。这种行为，对于处理配置默认值、用户自定义设置等场景，简直是神器。不过，也正是这种“无差别收集”的特性，有时候会让我们得到比预期更深的嵌套，需要在使用时多留心。

PHP中`array_merge()`和`array_merge_recursive()`有什么区别？

这个问题是很多PHP开发者初学数组合并时都会遇到的“坎儿”。说实话，一开始我也经常混淆，毕竟名字太像了。但它们的核心差异在于如何处理冲突的字符串键以及是否进行递归合并。

array_merge()：
- 非递归：它只处理数组的第一层。
- 字符串键冲突：如果多个数组中有相同的字符串键，后面数组的值会覆盖前面数组的值。
- 数值键冲突：所有数值键的值都会被追加到结果数组中，并重新索引。
- 适用场景：当你需要简单地合并两个或多个数组，并且希望后面数组的同名键值能直接替换掉前面数组的值时。比如，合并查询参数，或者用用户提交的数据覆盖默认设置。
```
<?php
$arrA = ['id' => 1, 'data' => ['a' => 1]];
$arrB = ['id' => 2, 'data' => ['b' => 2]];
$merged = array_merge($arrA, $arrB);
print_r($merged);
// 输出：Array ( [id] => 2 [data] => Array ( [b] => 2 ) )
// 注意，data键被完全覆盖了，arrA中的['a' => 1]丢失了。
?>
```
array_merge_recursive()：
- 递归：它会深入到嵌套数组中进行合并。
- 字符串键冲突：这是关键。当遇到相同的字符串键时，它不会覆盖，而是将所有冲突的值（无论是标量还是数组）都合并到一个新的数组中。如果冲突的值都是数组，它会递归地合并这些子数组。
- 数值键冲突：和 array_merge() 一样，所有数值键的值都会被追加并重新索引。
- 适用场景：当你需要深度合并复杂的配置结构、多层级的用户权限，或者任何你希望所有冲突的值都能被保留下来，而不是简单替换的场景。
```
<?php
$arrA = ['id' => 1, 'data' => ['a' => 1]];
$arrB = ['id' => 2, 'data' => ['b' => 2]];
$mergedRecursive = array_merge_recursive($arrA, $arrB);
print_r($mergedRecursive);
// 输出：Array ( [id] => Array ( [0] => 1 [1] => 2 ) [data] => Array ( [a] => 1 [b] => 2 ) )
// 这里id被合并成了一个数组，data内部的a和b也被保留了。
?>
```
总结一下，如果你的数组结构是扁平的，或者你明确知道后面数组的值应该覆盖前面数组的值，用 array_merge() 就够了。但如果你的数组有嵌套，并且你希望所有层级的冲突都能被“收集”起来，而不是简单覆盖，那么 array_merge_recursive() 才是你的最佳选择。

在合并PHP数组时，如何处理不同类型的值冲突？

array_merge_recursive() 在处理不同类型的值冲突时，它的行为确实挺有意思，也常常是开发者会感到困惑的地方。它的基本原则是：尽量保留所有信息，倾向于将非数组值转换为数组来容纳冲突。

我们来详细看看几种常见的冲突情况：

字符串键，值一个是标量，另一个也是标量： 这是最常见的情况。例如： $arr1 = ['key' => 'value1'];$arr2 = ['key' => 'value2'];array_merge_recursive($arr1, $arr2) 的结果会是 ['key' => ['value1', 'value2']]。它把两个标量值都放进了一个新的数组里。
字符串键，值一个是数组，另一个是标量： 这种场景也挺多。 $arr1 = ['key' => ['sub_key' => 'sub_value1']];$arr2 = ['key' => 'value2'];array_merge_recursive($arr1, $arr2) 的结果会是 ['key' => ['sub_key' => 'sub_value1', 0 => 'value2']]。可以看到，原有的数组结构被保留了，而标量值被当作一个新的元素追加到了这个数组的末尾，并赋予了数值索引。这可能会导致一些意想不到的数值索引出现，如果你期望的是一个纯关联数组，可能需要后期处理。
字符串键，值都是数组： 这是 array_merge_recursive() 最“本职”的工作。 $arr1 = ['key' => ['sub_key1' => 'value1']];$arr2 = ['key' => ['sub_key2' => 'value2']];array_merge_recursive($arr1, $arr2) 的结果会是 ['key' => ['sub_key1' => 'value1', 'sub_key2' => 'value2']]。如果子数组内部还有同名键，它会继续递归合并。

实际应用中的思考：

这种处理方式的优点是信息不丢失，所有冲突的值都被保留了下来。但缺点也很明显，它可能会导致结果数组的结构变得复杂，尤其是当标量值被“强制”塞进数组时。你可能需要编写额外的逻辑来处理这些新生成的数值键，或者在合并后对数组进行清理。

举个例子，假设你正在合并用户设置：

<?php
$defaultSettings = ['theme' => 'light', 'permissions' => ['read' => true, 'write' => false]];
$userSettings = ['theme' => 'dark', 'permissions' => 'admin']; // 用户不小心把permissions设成了字符串

$finalSettings = array_merge_recursive($defaultSettings, $userSettings);
print_r($finalSettings);
?>

结果会是：

Array
(
    [theme] => Array
        (
            [0] => light
            [1] => dark
        )

    [permissions] => Array
        (
            [read] => 1
            [write] => 
            [0] => admin
        )

)

你看，theme 被合并成了数组，permissions 更是把布尔值和字符串混在了一起。这显然不是我们想要的结果。在这种情况下，array_merge_recursive() 的这种“包容”策略反而成了障碍。这时，你可能需要考虑其他合并策略，比如 array_replace_recursive()，或者在合并前对输入数据进行严格的类型校验和预处理。理解这一点，对于避免潜在的bug和构建健壮的应用非常关键。

除了`array_merge_recursive()`，PHP还有哪些合并数组的方法，它们适用哪些场景？

PHP在数组操作上确实提供了不少工具，除了 array_merge_recursive() 之外，还有一些其他合并数组的方法，它们各有侧重，适用于不同的场景。选择哪个函数，很大程度上取决于你希望如何处理键冲突和数组深度。

+ 运算符 (Array Union) 这是最简洁的数组合并方式之一，但它的行为可能与直觉有些不同。
- 行为：它会把右边数组中不存在于左边数组的键值对添加到左边数组。如果键在左边数组中已经存在，那么左边数组的值会保持不变，右边数组的同名键值会被忽略。
- 数值键：数值键会被保留，不会重新索引。
- 递归性：不具备递归性，只处理第一层。
- 适用场景：非常适合用来设置默认值。比如，你有一个默认配置数组，然后想用用户提供的配置来覆盖它，但只覆盖那些用户明确指定了的项，而保留默认配置中未被用户指定的项。
```
<?php
$defaultOptions = ['timeout' => 30, 'cache' => true, 'mode' => 'strict'];
$userOptions = ['cache' => false, 'retries' => 3];

$finalOptions = $userOptions + $defaultOptions; // 注意顺序，右边的元素会补充左边
print_r($finalOptions);
// 输出：Array ( [cache] => false [retries] => 3 [timeout] => 30 [mode] => strict )
// userOptions中的cache覆盖了defaultOptions，而retries被添加，timeout和mode则保留了defaultOptions的值。
?>
```
array_replace() 和 array_replace_recursive() 这两个函数是 array_merge() 和 array_merge_recursive() 的“替换”版本，它们的核心区别在于处理字符串键的方式。
- array_replace()：
  - 行为：与 array_merge() 类似，但当字符串键冲突时，它会用后面数组的值替换前面数组的值。数值键会被保留，不会重新索引。
  - 递归性：非递归。
  - 适用场景：当你需要用新的值完全替换旧的值，包括那些空值或者 null。它在某种程度上比 array_merge() 更“强硬”地替换。
```
<?php
$arr1 = ['a' => 1, 'b' => 2];
$arr2 = ['a' => 10, 'c' => 3];
$replaced = array_replace($arr1, $arr2);
print_r($replaced);
// 输出：Array ( [a] => 10 [b] => 2 [c] => 3 )
// a被替换，c被添加。
?>
```
- array_replace_recursive()：
  - 行为：这是 array_merge_recursive() 的一个重要替代品。它会递归地替换数组中的值。如果字符串键在多个数组中都存在，后面数组的值会替换前面数组的值。但如果被替换的值本身是数组，它会递归地进行替换。
  - 递归性：递归。
  - 适用场景：当你需要深度合并配置，并且希望后面数组的同名键值能够替换（而不是像 array_merge_recursive() 那样合并成新数组）前面数组的值时。这对于更新深层配置非常有用。
```
<?php
$configDefaults = [
    'database' => ['host' => 'localhost', 'port' => 3306],
    'logging' => ['level' => 'info']
];
$userConfig = [
    'database' => ['port' => 5432], // 只想改端口
    'logging' => ['level' => 'debug', 'file' => '/var/log/app.log']
];

$finalConfig = array_replace_recursive($configDefaults, $userConfig);
print_r($finalConfig);
// 输出：
// Array
// (
//     [database] => Array
//         (
//             [host] => localhost
//             [port] => 5432 // port被替换了，host保留
//         )
//     [logging] => Array
//         (
//             [level] => debug // level被替换
//             [file] => /var/log/app.log // file被添加
//         )
// )
?>
```
  可以看到，array_replace_recursive() 在处理冲突时更加“保守”，它会尝试替换而不是合并成一个新数组。这在很多配置更新的场景下，比 array_merge_recursive() 更加符合预期。
手动循环合并 在某些非常复杂或需要高度定制的合并逻辑时，上述函数可能无法满足需求。例如，你可能需要根据某个条件来决定是否合并某个键，或者在合并时对值进行转换。
- 行为：完全由你控制，可以遍历一个或多个数组，根据自定义逻辑进行合并。
- 适用场景：当你需要对合并过程有极致的控制，或者内置函数无法满足你特定的业务逻辑时。这通常涉及 foreach 循环、条件判断等。
选择哪种合并方式，真的取决于你的具体需求：是想要保留所有冲突的值，还是希望新的值覆盖旧的值？是只处理第一层，还是要深入到嵌套数组？理解这些函数的细微差别，能帮助你更有效地处理PHP中的数组操作，避免一些常见的“坑”。