PHP合并数组的几种实用方法

小伙伴们对文章编程感兴趣吗？是否正在学习相关知识点？如果是，那么本文《PHP合并数组的常用方法与技巧》，就很适合你，本篇文章讲解的知识点主要包括。在之后的文章中也会多多分享相关知识点，希望对大家的知识积累有所帮助！

PHP合并数组的核心在于处理键冲突，+运算符保留左侧数组的值，array_merge()用右侧覆盖左侧并重新索引数字键，array_replace()则按键替换且不重置数字键。

PHP中合并两个数组，核心思路无非两种：一种是简单地把一个数组的元素追加到另一个后面，另一种则是在合并时考虑键名冲突的处理方式。常用的函数包括 array_merge()、array_replace()，以及一个常常被忽略但行为独特的 + 运算符。理解它们各自处理键冲突的逻辑，就能在不同场景下做出正确的选择。

解决方案

PHP提供了多种合并数组的方法，每种方法在处理键冲突时都有其独特的行为。

1. 使用 + 运算符（联合运算符）

当使用 + 运算符合并两个数组时，它会将右侧数组的元素追加到左侧数组。关键在于，如果两个数组中存在相同的字符串键名，那么左侧数组的值会被保留，右侧数组中对应键的值则会被忽略。对于数字键名，它会保留左侧数组的数字键和值，然后将右侧数组中不存在于左侧的数字键及其值追加进来。

 1, 'b' => 2, 0 => 'foo'];
$arr2 = ['b' => 3, 'c' => 4, 0 => 'bar', 1 => 'baz'];

$result = $arr1 + $arr2;
print_r($result);
/* 输出:
Array
(
    [a] => 1
    [b] => 2  // 'b' 在arr1中已存在，arr2的'b'被忽略
    [0] => foo // 0 在arr1中已存在，arr2的0被忽略
    [c] => 4
    [1] => baz
)
*/

$arr3 = [1, 2, 3]; // 隐式键 0, 1, 2
$arr4 = [4, 5, 6]; // 隐式键 0, 1, 2
$result2 = $arr3 + $arr4;
print_r($result2);
/* 输出:
Array
(
    [0] => 1
    [1] => 2
    [2] => 3
)
// 只有arr3的元素被保留，因为arr4的键都已存在于arr3
*/
?>

2. 使用 array_merge() 函数

array_merge() 是最常用的数组合并函数之一。它会将一个或多个数组合并到一起。如果输入的数组中有相同的字符串键名，后面数组的值会覆盖前面数组的值。如果数组包含数字键名，array_merge() 会对数字键进行重新索引（从0开始）。

 1, 'b' => 2, 0 => 'foo'];
$arr2 = ['b' => 3, 'c' => 4, 0 => 'bar', 1 => 'baz'];

$result = array_merge($arr1, $arr2);
print_r($result);
/* 输出:
Array
(
    [a] => 1
    [b] => 3  // 'b' 在arr2中覆盖了arr1的值
    [0] => foo // 0 在arr1中
    [1] => bar // arr2的0被重新索引为1
    [2] => baz // arr2的1被重新索引为2
    [c] => 4
)
*/

$arr3 = [1, 2, 3];
$arr4 = [4, 5, 6];
$result2 = array_merge($arr3, $arr4);
print_r($result2);
/* 输出:
Array
(
    [0] => 1
    [1] => 2
    [2] => 3
    [3] => 4
    [4] => 5
    [5] => 6
)
// 所有元素都被追加，并重新索引
*/
?>

3. 使用 array_replace() 函数

array_replace() 函数与 array_merge() 类似，但它主要用于替换数组中的值。它用后面数组的值替换前面数组中相同键名的值。不同之处在于，array_replace() 不会重新索引数字键名，而是直接根据键名进行替换。如果后面数组的键名在前面数组中不存在，则会添加该键值对。

 1, 'b' => 2, 0 => 'foo', 10 => 'ten'];
$arr2 = ['b' => 3, 'c' => 4, 0 => 'bar', 1 => 'baz'];

$result = array_replace($arr1, $arr2);
print_r($result);
/* 输出:
Array
(
    [a] => 1
    [b] => 3    // 'b' 在arr2中覆盖了arr1的值
    [0] => bar  // 0 在arr2中覆盖了arr1的值
    [10] => ten
    [1] => baz  // 1 在arr1中不存在，被添加
    [c] => 4    // 'c' 在arr1中不存在，被添加
)
*/

$arr3 = [1, 2, 3]; // 隐式键 0, 1, 2
$arr4 = [0 => 4, 1 => 5, 3 => 6]; // 显式键 0, 1, 3
$result2 = array_replace($arr3, $arr4);
print_r($result2);
/* 输出:
Array
(
    [0] => 4 // arr4的0覆盖arr3的0
    [1] => 5 // arr4的1覆盖arr3的1
    [2] => 3
    [3] => 6 // arr4的3被添加
)
*/
?>

PHP合并数组时，键冲突了怎么办？+操作符和array_merge()有何不同？

这是个老生常谈的问题，也是很多初学者容易混淆的地方。说白了，处理键冲突是合并数组时最核心的考量。

+ 运算符和 array_merge() 在处理键冲突时的行为差异，是它们最根本的区别，直接决定了你在什么场景下该用谁。

+ 运算符的键冲突处理：

+ 运算符，我个人觉得它更像是一种“补充”或者“填充”操作。当两个数组进行 + 运算时：

1. 字符串键名冲突： 如果两个数组都有相同的字符串键名，+ 运算符会保留左侧数组的值。右侧数组中对应键的值会被完全忽略。 比如 $arr1 = ['a' => 1]; $arr2 = ['a' => 2]; $result = $arr1 + $arr2; 那么 $result['a'] 依然是 1。这对于你想用一个默认数组作为基础，然后用另一个数组来“补齐”缺失的元素，而不是“覆盖”已有的元素时，非常有用。

2. 数字键名冲突： 行为和字符串键名类似，如果左侧数组已经有了某个数字键，右侧数组中同名的数字键及其值也会被忽略。只有右侧数组中那些在左侧数组不存在的数字键（包括其值）才会被追加进来。 举个例子，$arr1 = [0 => 'a', 1 => 'b']; $arr2 = [0 => 'x', 2 => 'y']; $result = $arr1 + $arr2; 结果会是 [0 => 'a', 1 => 'b', 2 => 'y']。$arr2 中的 0 => 'x' 被忽略了，因为 $arr1 已经有键 0 了。

array_merge() 的键冲突处理：

array_merge() 则更倾向于“整合”和“覆盖”。

1. 字符串键名冲突： 如果有相同的字符串键名，array_merge() 会用后面数组的值覆盖前面数组的值。这是它最常见的行为，也是我们通常期望的“合并”效果，即最新传入的数据优先。 比如 $arr1 = ['a' => 1]; $arr2 = ['a' => 2]; $result = array_merge($arr1, $arr2); 那么 $result['a'] 会是 2。

2. 数字键名冲突： array_merge() 在处理数字键时，会重新索引所有数字键。它会把所有输入数组的数字键值对都取出来，然后从 0 开始，为它们分配新的连续数字键。所以，严格来说，这里没有“冲突”的概念，只有“追加并重新索引”。 例如 $arr1 = [0 => 'a', 1 => 'b']; $arr2 = [0 => 'x', 1 => 'y']; $result = array_merge($arr1, $arr2); 结果会是 [0 => 'a', 1 => 'b', 2 => 'x', 3 => 'y']。$arr2 的 0 和 1 并没有覆盖 $arr1 的，而是作为新的元素被追加到了后面，并获得了新的索引。

总结一下：

• 如果你想用一个数组作为默认值或基础，然后用另一个数组非破坏性地添加新元素（保留原有相同键的值），那么 + 运算符是你的朋友。
• 如果你想整合多个数组，并且希望后面数组的相同字符串键值能覆盖前面数组的，同时数字键能被追加并重新索引，那么 array_merge() 是更标准、更常用的选择。

理解了这些，你就能根据实际需求，避免很多意想不到的数据丢失或逻辑错误。

除了简单合并，PHP还有哪些高级数组合并或替换技巧？array_replace()和array_merge_recursive()的适用场景是什么？

除了上面提到的 + 运算符和 array_merge()，PHP还提供了一些更“高级”或特定场景下使用的函数，比如 array_replace() 和 array_merge_recursive()。它们解决的问题和适用场景都略有不同。

array_replace() 的适用场景：

array_replace() 更侧重于“替换”而非单纯的“合并”。它会用后面数组的元素去替换前面数组中相同键名的元素。如果后面数组中有前面数组没有的键，则会新增。它的一个关键特点是：它会保留数字键名，不像 array_merge() 那样重新索引。

典型场景：

1. 更新配置或默认值： 这是 array_replace() 最常见的用途。你有一个包含默认配置的数组，然后用户或程序提供了一个局部配置数组，你想用局部配置去覆盖默认配置中的某些项，同时保留默认配置中未被覆盖的项，并且不希望数字键被重新索引。

    'localhost',
       'port' => 3306,
       'user' => 'root',
       'options' => [
           'timeout' => 5,
           'retries' => 3
       ]
   ];
   $user_config = [
       'port' => 8888,
       'password' => '123456'
   ];
   
   $final_config = array_replace($default_config, $user_config);
   print_r($final_config);
   /* 输出:
   Array
   (
       [host] => localhost
       [port] => 8888
       [user] => root
       [options] => Array
           (
               [timeout] => 5
               [retries] => 3
           )
       [password] => 123456
   )
   */
   ?>

   这里 port 被更新，password 被添加，其他未冲突的保持不变。

2. 部分数据更新： 当你需要根据一个小的更新数组来修改一个大的基础数组，并且希望保持原有数组的键结构（包括数字键）时，array_replace() 非常合适。

array_merge_recursive() 的适用场景：

array_merge_recursive() 顾名思义，是递归地合并数组。这意味着如果它在合并过程中遇到值是数组的键，它不会直接覆盖，而是会进入这些嵌套数组中，再次尝试合并它们。

典型场景：

1. 合并复杂的嵌套配置： 当你的配置或数据结构是多层嵌套的数组时，array_merge() 遇到嵌套数组会直接用后面数组的嵌套数组覆盖前面数组的，而 array_merge_recursive() 则会深入到嵌套数组中进行合并。

    [
           'host' => 'localhost',
           'user' => 'admin'
       ],
       'cache' => [
           'type' => 'redis'
       ]
   ];
   $config2 = [
       'database' => [
           'port' => 3306,
           'user' => 'guest' // 会覆盖
       ],
       'log' => [
           'level' => 'debug'
       ]
   ];
   
   $merged_config = array_merge_recursive($config1, $config2);
   print_r($merged_config);
   /* 输出:
   Array
   (
       [database] => Array
           (
               [host] => localhost
               [user] => guest // config2的user覆盖config1的user
               [port] => 3306
           )
       [cache] => Array
           (
               [type] => redis
           )
       [log] => Array
           (
               [level] => debug
           )
   )
   */
   ?>

array_merge_recursive() 的潜在问题：

它有一个需要注意的“坑”：如果递归合并时，某个键的值在第一个数组中不是数组，但在第二个数组中是数组，或者反过来，array_merge_recursive() 会把这些值都变成数组，并将它们作为新数组的元素。

 'value1'];
$arrB = ['data' => ['value2', 'value3']];

$result_recursive = array_merge_recursive($arrA, $arrB);
print_r($result_recursive);
/* 输出:
Array
(
    [data] => Array
        (
            [0] => value1
            [1] => value2
            [2] => value3
        )
)
*/
?>

这可能不是你期望的行为，所以在使用 array_merge_recursive() 时，要特别留意数据类型的一致性，或者在合并后进行额外的处理。对于更精细的深度合并，可能需要自己实现一个递归合并函数。

PHP合并数组时，性能和效率如何考量？有哪些潜在的坑或最佳实践？

当我们处理的数组规模不大时，其实 array_merge()、+ 运算符或者 array_replace() 之间的性能差异几乎可以忽略不计。但一旦涉及到非常大的数组，比如成千上万甚至几十万个元素的数组，或者在性能敏感的循环中频繁合并数组，那么对性能的考量就变得有意义了。

性能和效率考量：

1. 内存消耗： 大多数数组合并函数都会在内部创建新的数组来存储合并后的结果。这意味着在合并过程中，内存中可能会同时存在原始数组和合并后的新数组，这会增加内存开销。对于超大型数组，这可能导致内存耗尽。
2. CPU时间：
   • array_merge() 需要遍历所有输入数组，并可能对数字键进行重新索引，这涉及到更多的内部操作。通常，它的开销会比 + 运算符略高一些，尤其是在处理大量数字键的数组时。
   • + 运算符（联合运算符）在底层实现上可能更高效一些，因为它在处理键冲突时，只是简单地“跳过”右侧数组中已存在的键，而不需要像 array_merge() 那样进行覆盖或重新索引。
   • array_replace() 涉及到键的查找和替换，其性能通常介于 + 和 array_merge() 之间，具体取决于冲突和新增元素的数量。
   • array_merge_recursive() 由于其递归特性，在处理深层嵌套的复杂数组时，其开销会显著增加。

潜在的坑：

1. 意外的键值覆盖或丢失： 这是最常见的坑。如果你不清楚 + 运算符和 array_merge() 在键冲突时的具体行为，很容易导致数据不是你期望的样子。比如，你可能期望后面的数组覆盖前面的，结果却发现前面的值被保留了（使用了 + 运算符），或者你希望保留前面的值，结果却被覆盖了（使用了 array_merge()）。
2. 数字键重新索引的副作用： array_merge() 会重新索引数字键。如果你依赖原始的数字键作为某种标识符，那么 array_merge() 可能会破坏你的逻辑。这时候 array_replace() 或 + 运算符可能更合适。
3. array_merge_recursive() 的类型转换： 前面提到了，当 array_merge_recursive() 遇到相同键但不同类型（一个是非数组，另一个是数组）的值时，它会把它们都强制转换成数组，这可能导致意想不到的数据结构。
4. 大规模数组的性能瓶颈： 在循环中频繁地对大规模数组进行合并操作，可能迅速成为性能瓶颈。

最佳实践：

1. 选择正确的工具： 这是最重要的。根据你对键冲突处理、数字键保留或重新索引、以及是否需要深度合并的需求，选择最合适的函数。
   • 保留左侧数组的键值，补充右侧数组的非冲突键值： 使用 + 运算符。
   • 用右侧数组的键值覆盖左侧数组的键值，并重新索引数字键： 使用 array_merge()。
   • 用右侧数组的键值替换左侧数组的键值，并保留数字键： 使用 array_replace()。
   • 深度递归合并嵌套数组： 使用 array_merge_recursive()，但要警惕其类型转换行为。
2. 避免不必要的合并： 如果你只是想在数组末尾添加一个元素，直接使用 [] 语法（$arr[] = $value;）通常比合并一个新数组更高效。
3. 对大规模数组进行优化：
   • 减少合并次数： 如果有多个小数组要合并到一个大数组中，考虑一次性将所有小数组作为参数传递给 array_merge()，而不是在一个循环中多次合并。array_merge($arr1, $arr2, $arr3, ...) 效率通常高于 array_merge(array_merge($arr1, $arr2), $arr3)。
   • 手动迭代： 对于极端性能要求，或者需要非常精细的合并逻辑（例如，合并时进行数据验证、转换），你可能需要放弃内置函数，手动编写循环来遍历和添加元素，这样可以更好地控制内存和操作

今天带大家了解了的相关知识，希望对你有所帮助；关于文章的技术知识我们会一点点深入介绍，欢迎大家关注golang学习网公众号，一起学习编程~