PHP 数组合并策略：从左右连接到深度递归，掌握数据整合精髓20

在 PHP 的日常开发中，数组作为最常用的数据结构之一，承载着大量的数据存储和处理任务。无论是从数据库查询结果、API 响应还是用户输入中获取数据，我们常常需要将多个数组进行整合，以形成一个更完整、更有序或更符合业务逻辑的数据集合。这个过程，我们形象地称之为“数组合并”，或者按照标题所说的“数组左右合并”。

“左右合并”并非一个 PHP 官方术语，但它生动地描述了将一个数组的元素“追加”到另一个数组的“右侧”，或者将一个数组的键值对“覆盖”或“结合”到另一个数组上的过程。理解 PHP 提供的各种数组合并机制，并根据实际场景选择最合适的方法，是每个专业 PHP 开发者必备的技能。本文将深入探讨 PHP 数组的各种合并方式，包括其核心原理、使用场景、键值对处理规则、性能考量以及多维数组的深度合并技巧，助你全面掌握 PHP 数组的数据整合精髓。

一、PHP 数组左右合并的基本概念与核心需求

当我们谈论“PHP 数组左右合并”时，通常指的是以下几种常见的需求：
简单追加（Append）：将一个数组的所有元素直接追加到另一个数组的末尾，形成一个更长的数组。这在处理列表型数据时非常常见。
键值对组合（Combine/Overlay）：将两个关联数组基于它们的键进行合并。如果键存在冲突，需要决定是保留哪个数组的值，还是以某种方式组合这些值。这在合并配置、用户资料或具有唯一标识符的数据时很常见。
多维数组的深度合并（Deep Merge）：当数组包含其他数组时（即多维数组），合并操作可能需要递归地进入子数组进行合并，而不是仅仅在顶层进行覆盖或追加。

PHP 提供了多种内置函数和运算符来满足这些合并需求，每种方法在处理索引数组和关联数组时都有其独特的行为。

二、核心合并方法解析：array_merge() 与数组联合运算符 (+)

PHP 中最基础也是最常用的“左右合并”方法是 `array_merge()` 函数和数组联合运算符 `+`。它们在处理键名冲突时有着显著的区别。

2.1 array_merge() 函数：追加与覆盖之选

`array_merge()` 是一个强大的函数，可以接受一个或多个数组作为参数，并将它们合并成一个新数组。它的主要行为特点是：
索引数组（Numeric Keys）：对于以数字为键名的数组，`array_merge()` 会重新索引所有的数字键，从 0 开始递增。它会将所有数组的元素简单地追加在一起。
关联数组（String Keys）：对于以字符串为键名的数组，如果不同数组中存在相同的键名，后一个数组的值会覆盖前一个数组中同键名的值。

示例：
<?php
// 索引数组合并
$array1 = [1, 2, 3];
$array2 = [4, 5, 6];
$mergedIndexed = array_merge($array1, $array2);
// 结果: [0 => 1, 1 => 2, 2 => 3, 3 => 4, 4 => 5, 5 => 6]
echo '索引数组合并 (array_merge): <pre>'; print_r($mergedIndexed); echo '</pre>';
$array3 = ['a' => 'apple', 'b' => 'banana'];
$array4 = ['c' => 'cherry', 'a' => 'apricot']; // 'a' 键冲突
$mergedAssociative = array_merge($array3, $array4);
// 结果: ['a' => 'apricot', 'b' => 'banana', 'c' => 'cherry']
echo '关联数组合并 (array_merge): <pre>'; print_r($mergedAssociative); echo '</pre>';
// 混合数组合并
$array5 = [0 => 'red', 'color' => 'blue', 1 => 'green'];
$array6 = [0 => 'yellow', 'color' => 'orange', 'size' => 'large'];
$mergedMixed = array_merge($array5, $array6);
// 结果: [0 => 'green', 'color' => 'orange', 1 => 'yellow', 'size' => 'large']
// 注意：索引键 0 被重新索引并覆盖，但实际是 0 和 1 两个数字键被重新分配了新的位置。
// array_merge 在遇到相同数字键时，不会覆盖，而是追加并重新索引。
// 这里的 0 => 'red' (from $array5) and 0 => 'yellow' (from $array6) 实际上被当作不同的元素处理
// 后者追加到前者之后，然后所有的数字键再被重新索引。
echo '混合数组合并 (array_merge): <pre>'; print_r($mergedMixed); echo '</pre>';
?>

总结 `array_merge()`：
优点：简单直观，适用于绝大多数追加和覆盖场景；能够接受多个数组作为参数。
缺点：重新索引数字键可能会改变原有的顺序和含义；对关联键冲突总是采用覆盖策略，可能不适用于某些需要保留所有值的场景。

2.2 数组联合运算符 (+)：保留与叠加

PHP 中的 `+` 运算符也可以用于合并数组，但它的行为与 `array_merge()` 完全不同，尤其是在处理键名冲突时：
索引数组（Numeric Keys）：数组联合运算符会保留左边数组的数字键。如果右边数组的某个数字键与左边数组的数字键相同，那么右边数组的值会被忽略，左边数组的值保持不变。如果右边数组的数字键在左边数组中不存在，则会被追加。
关联数组（String Keys）：如果不同数组中存在相同的字符串键名，左边数组的值会被保留，右边数组中同键名的值会被忽略。也就是说，左边数组优先。

示例：
<?php
// 索引数组合并
$array1 = [1, 2, 3];
$array2 = [0 => 4, 1 => 5, 3 => 6]; // 注意键 0 和 1 冲突，键 3 不冲突
$mergedIndexed = $array1 + $array2;
// 结果: [0 => 1, 1 => 2, 2 => 3, 3 => 6]
// $array2 的 0 => 4 和 1 => 5 被 $array1 的 0 => 1 和 1 => 2 覆盖（即保留了左侧的值）
echo '索引数组合并 (联合运算符 +): <pre>'; print_r($mergedIndexed); echo '</pre>';
// 关联数组合并
$array3 = ['a' => 'apple', 'b' => 'banana'];
$array4 = ['c' => 'cherry', 'a' => 'apricot']; // 'a' 键冲突
$mergedAssociative = $array3 + $array4;
// 结果: ['a' => 'apple', 'b' => 'banana', 'c' => 'cherry']
// $array4 的 'a' => 'apricot' 被 $array3 的 'a' => 'apple' 覆盖（即保留了左侧的值）
echo '关联数组合并 (联合运算符 +): <pre>'; print_r($mergedAssociative); echo '</pre>';
// 混合数组合并
$array5 = [0 => 'red', 'color' => 'blue', 1 => 'green'];
$array6 = [0 => 'yellow', 'color' => 'orange', 'size' => 'large'];
$mergedMixed = $array5 + $array6;
// 结果: [0 => 'red', 'color' => 'blue', 1 => 'green', 'size' => 'large']
// 数字键 0 的 'yellow' 被 'red' 覆盖，字符串键 'color' 的 'orange' 被 'blue' 覆盖。
echo '混合数组合并 (联合运算符 +): <pre>'; print_r($mergedMixed); echo '</pre>';
?>

总结联合运算符 `+`：
优点：在键冲突时保留左边数组的值，适用于需要叠加而不覆盖的场景，例如默认配置与用户自定义配置的合并。
缺点：行为对于初学者可能不如 `array_merge()` 直观；不能接受多个数组参数，需要链式操作或多次合并；数字键的行为有时会出人意料。

三、深度合并：array_merge_recursive() 与自定义递归函数

当数组中包含嵌套的子数组时，简单的 `array_merge()` 和 `+` 运算符可能无法满足需求。`array_merge()` 只在顶层进行合并，如果某个键的值是一个数组，它会直接用后一个数组的子数组替换前一个数组的子数组。而 `+` 运算符则会保留左边数组的子数组。为了实现多维数组的深度合并，PHP 提供了 `array_merge_recursive()` 函数，或者我们可以编写自定义的递归合并函数。

3.1 array_merge_recursive() 函数：递归合并利器

`array_merge_recursive()` 函数以递归的方式合并数组。它的行为规则如下：
数字键：不会覆盖，而是将所有相同数字键的值（即使它们不是数组）都放入一个新的数组中。
字符串键：如果值是标量（非数组），则像 `array_merge()` 一样，后一个值覆盖前一个。但如果相同键名的值都是数组，那么它会递归地合并这些子数组。

示例：
<?php
$config1 = [
'database' => [
'host' => 'localhost',
'port' => 3306,
'user' => 'root'
],
'settings' => [
'debug' => true,
'timeout' => 30
],
'list' => [1, 2]
];
$config2 = [
'database' => [
'port' => 3307, // 覆盖
'password' => '123456' // 新增
],
'settings' => [
'timeout' => 60, // 覆盖
'log_level' => 'info' // 新增
],
'list' => [3, 4], // 数字键的特殊处理
'new_item' => 'value'
];
$mergedRecursive = array_merge_recursive($config1, $config2);
// 结果:
// [
// 'database' => [
// 'host' => 'localhost',
// 'port' => 3307,
// 'user' => 'root',
// 'password' => '123456'
// ],
// 'settings' => [
// 'debug' => true,
// 'timeout' => 60,
// 'log_level' => 'info'
// ],
// 'list' => [
// 0 => 1,
// 1 => 2,
// 2 => 3,
// 3 => 4
// ], // 注意：数字键的值被合并成了一个新的数组
// 'new_item' => 'value'
// ]
echo '多维数组合并 (array_merge_recursive): <pre>'; print_r($mergedRecursive); echo '</pre>';
?>

总结 `array_merge_recursive()`：
优点：能够处理任意深度的多维数组合并。
缺点：对于相同的数字键，它会将所有值收集到一个新的数组中，而不是覆盖或重新索引。这可能不是你期望的行为，例如，你可能希望`[1,2]`合并`[3,4]`后得到`[1,2,3,4]`而不是`[[1,2],[3,4]]`或`[1,2,3,4]`。

3.2 自定义递归合并函数：灵活控制深度合并逻辑

由于 `array_merge_recursive()` 在处理数字键时的特殊行为，有时我们需要更精细地控制深度合并的逻辑。这时，编写一个自定义的递归合并函数就变得非常必要。

一个常见的自定义深度合并函数，通常会模仿 `array_merge()` 和 `+` 运算符在不同情况下的行为。例如，对于同名的关联键，希望后者覆盖前者；而对于同名的索引键，则希望追加而非创建嵌套数组。
<?php
function array_deep_merge(array &$array1, array &$array2): array
{
$merged = $array1;
foreach ($array2 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 = [
'database' => [
'host' => 'localhost',
'port' => 3306,
'user' => 'root'
],
'settings' => [
'debug' => true,
'timeout' => 30
],
'list' => ['itemA', 'itemB']
];
$config2 = [
'database' => [
'port' => 3307,
'password' => '123456'
],
'settings' => [
'timeout' => 60,
'log_level' => 'info'
],
'list' => ['itemC', 'itemD'], // 期望这里追加而不是覆盖
'new_item' => 'value'
];
$customMerged = array_deep_merge($config1, $config2);
// 这里的 array_deep_merge 实现了一个 '后一个覆盖前一个' 的策略，
// 并且在处理非数组项和索引数组项时，默认采取覆盖或简单追加（如果键不存在）。
// 对于 list 的行为，需要更复杂的逻辑来判断是追加还是覆盖。
// 上述代码 'list' => ['itemC', 'itemD'] 会直接覆盖 'list' => ['itemA', 'itemB']。
// 如果我们希望 'list' 像 array_merge 那样追加，可以这样调整：
function array_deep_merge_enhanced(array $array1, array $array2): array
{
$merged = $array1;
foreach ($array2 as $key => $value) {
if (is_int($key) || !isset($merged[$key])) { // 如果是数字键，或者键不存在，直接添加/追加
$merged[] = $value; // 相当于 array_merge 的数字键处理
} elseif (is_array($value) && is_array($merged[$key])) {
$merged[$key] = array_deep_merge_enhanced($merged[$key], $value);
} else { // 字符串键存在且不是数组，后者覆盖前者
$merged[$key] = $value;
}
}
return $merged;
}
$config3 = [
'database' => [
'host' => 'localhost',
'port' => 3306
],
'list' => [1, 2]
];
$config4 = [
'database' => [
'port' => 3307,
'user' => 'admin'
],
'list' => [3, 4],
'new_key' => 'new_value'
];
$customMergedEnhanced = array_deep_merge_enhanced($config3, $config4);
// 期望结果：
// [
// 'database' => [
// 'host' => 'localhost',
// 'port' => 3307,
// 'user' => 'admin'
// ],
// 'list' => [0 => 1, 1 => 2, 2 => 3, 3 => 4], // 期望追加
// 'new_key' => 'new_value'
// ]
echo '自定义增强版多维数组合并 (array_deep_merge_enhanced): <pre>'; print_r($customMergedEnhanced); echo '</pre>';
?>

总结自定义递归函数：
优点：提供了最大的灵活性，可以根据业务需求精确控制合并行为（例如，数字键是追加、覆盖还是合并成数组）。
缺点：实现相对复杂，需要考虑各种边缘情况。

四、性能考量与最佳实践

在选择数组合并方法时，除了功能上的差异，性能也是一个需要考虑的因素，尤其是在处理大型数组或高频调用时。

4.1 性能比较

`array_merge()` vs `+`：对于关联数组，`+` 运算符通常比 `array_merge()` 稍快，因为它不需要为冲突的键执行值覆盖操作，只需判断键是否存在。对于纯索引数组，`array_merge()` 可能会更高效，因为它专注于重新索引和追加。然而，这些性能差异在大多数非极端情况下可以忽略不计。
`array_merge_recursive()`：由于其递归的特性，处理多维数组会比扁平数组合并更耗时，但对于其设计目的（深度合并），它是最高效的内置函数。
自定义递归函数：性能取决于实现细节。如果逻辑复杂，可能会比内置函数慢。但如果能精准匹配需求，可以避免不必要的计算。

最佳实践：
明确需求：在选择合并方法之前，首先要清楚地知道你希望如何处理键冲突和数据结构：

需要简单追加新元素，并重新索引数字键吗？ → `array_merge()`
需要新元素覆盖旧元素（关联键），并重新索引数字键吗？ → `array_merge()`
需要保留现有元素（关联键和数字键），只添加不存在的新元素吗？ → `+` 运算符
需要深度合并多维数组，且对数字键的合并行为（嵌套数组）可接受？ → `array_merge_recursive()`
需要深度合并多维数组，但对数字键有特定处理逻辑（例如追加而非嵌套）？ → 自定义递归函数

避免在循环中频繁合并大型数组：数组合并操作会创建新数组，涉及内存分配和数据复制。在性能敏感的循环中，尽量避免对大型数组进行频繁的合并。考虑在循环结束后一次性合并，或者使用迭代器等更内存高效的方法。
理解数组键： PHP 数组的灵活性在于它既可以是索引数组（列表），也可以是关联数组（字典），甚至是混合型。不同的合并方法对这两种键的处理方式是核心差异，必须牢记。
参数传递：对于自定义递归合并函数，如果修改的是传入数组的引用（如 `&$array1`），可以减少内存开销。但要小心副作用。通常，返回一个新合并数组是更安全的做法。
考虑其他函数：有时，你的需求可能不是简单的“合并”。例如，如果你想合并两个数组的*值*，但要确保唯一性，可以考虑 `array_unique()`。如果你想合并两个数组，但只保留某个条件的元素，可以结合 `array_filter()`。`array_replace()` 和 `array_replace_recursive()` 也是处理关联数组覆盖的强大工具，它们与 `array_merge()` 类似，但只用于替换已有键，不会添加新数字键。

五、总结

“PHP 数组左右合并”是数据处理的核心操作，涵盖了从简单追加到复杂深度整合的多种场景。`array_merge()` 和 `+` 运算符是处理扁平数组合并的基础，它们的差异主要体现在对键冲突的处理上：前者倾向于覆盖（关联键）和重新索引（数字键），后者则倾向于保留左侧数组的值。

对于多维数组的深度合并，`array_merge_recursive()` 提供了开箱即用的解决方案，但其对数字键的处理方式（嵌套而非追加）可能并非总是理想。此时，编写一个符合业务逻辑的自定义递归合并函数，将是实现精细控制的最佳选择。

掌握这些合并工具及其背后的原理，结合性能考量和最佳实践，将使你能够更加自信和高效地处理 PHP 中的数组数据，编写出健壮且高性能的应用程序。

2025-11-23

上一篇：PHP实现安全高效的本地文件浏览与管理：从基础到高级实践

下一篇：精通 PHP 数组多次查询优化：告别低效，提升应用性能