PHP多维数组深度合并策略与最佳实践89

在PHP开发中，数组是最常用的数据结构之一。从简单的列表到复杂的配置信息、API响应数据，数组无处不在。然而，当处理多维数组时，尤其涉及到“合并”操作，事情往往会变得复杂起来。传统的 `array_merge()` 函数或 `+` 运算符在面对嵌套结构时力不从心，这正是“深度合并”多维数组需求出现的背景。本文将作为一名资深程序员，深入探讨PHP中多维数组的合并策略，从基础概念到自定义递归实现，再到性能优化与最佳实践，帮助您高效、优雅地处理复杂数组合并任务。

一、基础概念：PHP数组与合并的挑战

PHP数组是一种极其灵活的数据结构，可以同时作为有序列表（索引数组）和键值对集合（关联数组）。多维数组则是数组的数组，允许我们构建复杂的层次结构。例如：
$config1 = [
'app' => [
'name' => 'MyApp',
'env' => 'development',
'debug' => true,
],
'database' => [
'host' => 'localhost',
'port' => 3306,
],
'features' => ['featureA', 'featureB']
];
$config2 = [
'app' => [
'env' => 'production',
'debug' => false,
'timezone' => 'Asia/Shanghai',
],
'database' => [
'user' => 'admin',
'password' => 'secret',
],
'new_setting' => 'value',
'features' => ['featureC']
];

我们的目标通常是将 `config2` 的设置“合并”到 `config1` 中，其中 `config2` 的值应该覆盖 `config1` 的同名键，同时保留 `config1` 中 `config2` 没有的键，并添加 `config2` 中 `config1` 没有的键。而对于嵌套数组，我们期望的不是简单替换，而是逐层深入地合并。

`array_merge()` 和 `+` 运算符的局限性

PHP提供了几个内置函数和运算符用于数组合并，但它们在处理多维数组时有各自的限制：

`array_merge()` 函数：

此函数用于将一个或多个数组合并在一起。它的行为规则如下：
对于数字键（索引数组），它会将所有数组的元素追加到结果数组的末尾，并重新索引。
对于字符串键（关联数组），如果键名相同，后面数组的值会覆盖前面数组的值。
局限性： `array_merge()` 不会递归地合并多维数组。当遇到相同字符串键的值本身也是数组时，它会简单地用后面数组的整个子数组替换前面数组的子数组，而不是将它们内部的元素进行合并。这通常不是我们期望的“深度合并”行为。

$arr1 = ['a' => 1, 'b' => ['x' => 10, 'y' => 20]];
$arr2 = ['b' => ['z' => 30], 'c' => 3];
$merged = array_merge($arr1, $arr2);
// 结果：['a' => 1, 'b' => ['z' => 30], 'c' => 3]
// 注意：'b' => ['x' => 10, 'y' => 20] 被完全替换，而不是与 ['z' => 30] 合并

`+` 运算符：

数组的 `+` 运算符（联合运算符）主要用于将两个数组合并。它的行为规则是：
对于所有键（无论是数字还是字符串），如果左侧数组中已存在相同的键，则保留左侧数组中的值，右侧数组中该键的值会被忽略。
如果右侧数组中存在左侧数组没有的键，则将右侧数组的该键值对添加到结果数组中。
局限性： `+` 运算符的合并策略是“左侧优先”，且同样不具备递归合并能力。它对于更新或覆盖配置文件的场景不适用，因为它不会覆盖现有值。

$arr1 = ['a' => 1, 'b' => ['x' => 10]];
$arr2 = ['b' => ['z' => 30], 'c' => 3];
$merged = $arr1 + $arr2;
// 结果：['a' => 1, 'b' => ['x' => 10], 'c' => 3]
// 注意：'b' => ['z' => 30] 被忽略，因为 'b' 在 $arr1 中已存在

`array_merge_recursive()` 函数：

PHP也提供了一个名为 `array_merge_recursive()` 的函数，它听起来像是我们需要的深度合并。然而，它的行为往往出乎意料：
当遇到相同字符串键时，如果两个值都是非数组，则后面的值覆盖前面的值。
最关键的陷阱：如果两个相同字符串键的值都是数组，它会将它们递归合并。但如果其中一个或两个值都是非数组，它会将这些值转换成一个包含所有值的数组，而不是覆盖。例如，`['a' => 1]` 和 `['a' => 2]` 会合并成 `['a' => [1, 2]]`。这通常不符合我们“覆盖”或“更新”的预期。

$arr1 = ['a' => 1, 'b' => ['x' => 10]];
$arr2 = ['a' => 2, 'b' => ['y' => 20]];
$merged = array_merge_recursive($arr1, $arr2);
// 结果：['a' => [1, 2], 'b' => ['x' => 10, 'y' => 20]]
// 注意：'a' 的值变成了数组 [1, 2]，这通常不是想要的覆盖行为

鉴于 `array_merge_recursive()` 的这种“累加”而非“覆盖”的行为，它在大多数深度合并场景中并非理想选择。

因此，要实现真正的多维数组深度合并（其中后者优先覆盖前者，且对于嵌套数组进行递归合并），我们通常需要编写自定义的递归函数。

二、自定义递归实现：深度合并的核心

深度合并的核心思想是递归遍历两个或多个数组。当遇到相同的键时，如果它们都是数组，则递归地调用合并函数；否则，后面的值覆盖前面的值。如果键只存在于其中一个数组中，则直接添加。

基本的深度合并函数

下面是一个实现深度合并的PHP函数，它接受任意数量的数组作为参数，并按照“后传入的数组覆盖先传入的数组”的规则进行合并：
/
* 深度合并多个多维数组。
* 后续数组的值会覆盖前序数组的同名键值，并递归合并嵌套数组。
*
* @param array ...$arrays 待合并的数组列表
* @return array 合并后的数组
*/
function array_deep_merge(array ...$arrays): array
{
$merged = [];
foreach ($arrays as $array) {
foreach ($array as $key => $value) {
// 如果当前数组的值和已合并数组中相同键的值都是数组
if (is_array($value) && isset($merged[$key]) && is_array($merged[$key])) {
// 递归合并子数组
$merged[$key] = array_deep_merge($merged[$key], $value);
} else {
// 否则，直接覆盖或添加值
$merged[$key] = $value;
}
}
}
return $merged;
}

让我们用之前的 `config1` 和 `config2` 示例来测试这个函数：
$config1 = [
'app' => [
'name' => 'MyApp',
'env' => 'development',
'debug' => true,
],
'database' => [
'host' => 'localhost',
'port' => 3306,
],
'features' => ['featureA', 'featureB']
];
$config2 = [
'app' => [
'env' => 'production',
'debug' => false,
'timezone' => 'Asia/Shanghai',
],
'database' => [
'user' => 'admin',
'password' => 'secret',
],
'new_setting' => 'value',
'features' => ['featureC']
];
$finalConfig = array_deep_merge($config1, $config2);
echo "<pre>";
print_r($finalConfig);
echo "</pre>";
/*
输出结果大致为：
Array
(
[app] => Array
(
[name] => MyApp // 来自 config1
[env] => production // 来自 config2 (覆盖)
[debug] => false // 来自 config2 (覆盖)
[timezone] => Asia/Shanghai // 来自 config2 (新增)
)
[database] => Array
(
[host] => localhost // 来自 config1
[port] => 3306 // 来自 config1
[user] => admin // 来自 config2 (新增)
[password] => secret // 来自 config2 (新增)
)
[features] => ['featureC'] // 来自 config2 (完全替换，不是合并)
[new_setting] => value // 来自 config2 (新增)
)
*/

可以看到，`app` 和 `database` 嵌套数组被正确地递归合并了，`config2` 中的新键也被添加进来，同名键的值也被覆盖。然而，对于 `features` 键，`config1` 中的 `['featureA', 'featureB']` 被 `config2` 中的 `['featureC']` 完全替换了，而不是将 `featureC` 追加到 `featureA`, `featureB` 之后。这是因为我们的 `array_deep_merge` 函数在遇到非数组值时，会直接覆盖。即使它们都是数组，如果它们是“索引数组”，我们可能更希望进行追加，而不是替换。

三、增强型深度合并：处理索引数组与关联数组的差异

在许多场景中，我们希望对于关联数组（字符串键）进行递归覆盖合并，而对于索引数组（数字键）则进行追加合并。例如，一个配置项可能是 `['plugins' => ['pluginA', 'pluginB']]`，另一个配置项提供 `['plugins' => ['pluginC']]`，我们期望合并后得到 `['plugins' => ['pluginA', 'pluginB', 'pluginC']]`，而不是 `['plugins' => ['pluginC']]`。

为此，我们需要在递归合并函数中引入一个判断机制，来区分关联数组和索引数组，并采取不同的合并策略。
/
* 增强型深度合并多个多维数组。
* 字符串键（关联数组）的值会递归覆盖。
* 数字键（索引数组）的值会被追加，如果两个都是索引数组，则进行合并。
*
* @param array ...$arrays 待合并的数组列表
* @return array 合并后的数组
*/
function array_deep_merge_enhanced(array ...$arrays): array
{
$merged = [];
foreach ($arrays as $array) {
foreach ($array as $key => $value) {
// 检查当前键是否是数字键（通常代表索引数组的元素）
// 注意：PHP的is_int($key) 是判断键本身是否是整数
// 实际判断一个数组是“索引”还是“关联”，更常用检查其键的连续性
$is_numeric_key = is_int($key);
// 如果当前值和已合并数组中相同键的值都是数组
if (is_array($value) && isset($merged[$key]) && is_array($merged[$key])) {
// 判断两个子数组是否都是纯粹的索引数组 (即所有键都是0到count-1的连续整数)
// 这是一个常见的判断方式，但并非完美无缺，因为可能存在混合键的数组
// 对于更严格的判断，可以使用 array_is_list() (PHP 8.1+) 或检查所有键是否是连续的数字

// 简单判断：如果两个数组的键都是数字，我们倾向于追加
$merged_is_list = (array_keys($merged[$key]) === range(0, count($merged[$key]) - 1));
$value_is_list = (array_keys($value) === range(0, count($value) - 1));

if ($merged_is_list && $value_is_list) {
// 如果两者都是列表（索引数组），则追加元素
$merged[$key] = array_merge($merged[$key], $value);
} else {
// 否则，按关联数组对待，递归合并
$merged[$key] = array_deep_merge_enhanced($merged[$key], $value);
}
} elseif ($is_numeric_key) {
// 如果是数字键，且不是数组对数组的递归合并，则追加到结果中（像array_merge对待索引数组一样）
// 这确保了在最外层或非嵌套层级，索引数组也能被追加
$merged[] = $value; // 注意这里是 $merged[] 而不是 $merged[$key]，因为我们希望追加
} else {
// 否则，直接覆盖或添加值（非数组值，或其中一个不是数组）
$merged[$key] = $value;
}
}
}
return $merged;
}

注意：上述 `array_deep_merge_enhanced` 函数对于索引数组的处理更加复杂。特别是 `if ($is_numeric_key)` 内部的 `$merged[] = $value;` 会导致数字键被重新索引。如果您需要保留原始数字键，或者在合并时需要更精细的控制，这个函数可能还需要进一步调整。例如，一个更常见的处理方式是，即使是索引数组，如果它嵌套在关联数组的键下，依然当作关联数组进行递归合并，除非明确指示追加。

我们来简化一下对索引数组的处理，使其更符合“配置文件覆盖”的常见场景：所有相同键（无论数字还是字符串）都以“后者覆盖前者”为原则，但如果都是纯粹的索引数组，则进行追加。
/
* 优化后的深度合并函数，更好地处理索引数组和关联数组。
* 策略：
* 1. 如果键在两个数组中都存在：
* a. 如果两个值都是数组：
* i. 如果两个子数组都是纯索引数组（list）：进行 `array_merge` (追加)。
* ii. 否则（关联数组或混合数组）：进行递归合并 (覆盖)。
* b. 如果至少一个值不是数组：后者覆盖前者。
* 2. 如果键只在一个数组中存在：直接添加到结果中。
*
* @param array ...$arrays 待合并的数组列表
* @return array 合并后的数组
*/
function array_deep_merge_ultimate(array ...$arrays): array
{
$merged = [];
foreach ($arrays as $array) {
foreach ($array as $key => $value) {
if (isset($merged[$key]) && is_array($merged[$key]) && is_array($value)) {
// 检查子数组是否为纯索引数组 (PHP 8.1+ 可用 array_is_list)
$merged_is_list = array_is_list($merged[$key]); // 或者 array_keys($merged[$key]) === range(0, count($merged[$key]) - 1);
$value_is_list = array_is_list($value); // 或者 array_keys($value) === range(0, count($value) - 1);
if ($merged_is_list && $value_is_list) {
// 如果两者都是纯索引数组，则追加
$merged[$key] = array_merge($merged[$key], $value);
} else {
// 否则，按关联数组对待，递归合并
$merged[$key] = array_deep_merge_ultimate($merged[$key], $value);
}
} else {
// 如果其中一个不是数组，或者键不存在，则直接覆盖/添加
$merged[$key] = $value;
}
}
}
return $merged;
}

使用 `array_deep_merge_ultimate` 测试 `features` 示例：
$config1 = [
'features' => ['featureA', 'featureB']
];
$config2 = [
'features' => ['featureC', 'featureD']
];
$finalConfig = array_deep_merge_ultimate($config1, $config2);
echo "<pre>";
print_r($finalConfig);
echo "</pre>";
/*
输出结果：
Array
(
[features] => Array
(
[0] => featureA
[1] => featureB
[2] => featureC
[3] => featureD
)
)
*/