php 两个数组合并|权威技术指南

从array_merge到+运算符,深度解析PHP数组合并的原理、差异与实战技巧,覆盖索引、关联、混合数组场景

php 两个数组合并|核心概念与背景

在PHP开发中,数组是使用频率最高的数据结构之一。实际业务中,经常需要将两个数组合并为一个新数组,例如:合并用户基础信息与扩展配置、整合API返回的多段数据、聚合数据库查询结果等。

但“合并”并非简单拼接——PHP提供多种合并方式,每种在**索引键处理**、**键名冲突策略**、**递归深度**、**性能表现**上存在本质差异。错误选择合并方式,轻则数据丢失,重则引发安全漏洞(如重复键覆盖敏感字段)。

本文系统梳理5种主流合并方法,结合源码级原理分析与真实业务案例,助你精准选择最优方案。

合并的三大核心维度

评估一种合并方式是否适用,需关注以下三个关键维度:

例如:合并用户权限配置时,若用+运算符覆盖默认值,可能导致高权限配置被低权限值覆盖,引发越权风险。

php 两个数组合并|五大核心方法详解

1. array_merge()|默认合并方案

array_merge()是PHP内置最常用的合并函数,适用于大多数场景。其核心逻辑为:

  • 索引数组:保留所有元素,索引重新从0开始连续编号
  • 关联数组:保留所有键值对,后一个数组的同名键覆盖前一个

示例:

$a1 = [0 => 'apple', 1 => 'banana'];
$a2 = [0 => 'cherry', 2 => 'date'];
$result = array_merge($a1, $a2);
// 输出:['apple', 'banana', 'cherry', 'date']

注意:当合并关联数组时,键名冲突会导致覆盖:

$user = ['id' => 1, 'role' => 'user'];
$extra = ['role' => 'admin', 'level' => 5];
$merged = array_merge($user, $extra);
// 结果:['id' => 1, 'role' => 'admin', 'level' => 5] —— role被覆盖

源码级原理:PHP内部通过zval指针复制(copy-on-write),避免不必要的内存拷贝;对关联数组使用哈希表合并,时间复杂度O(n+m)。

适用场景:日志合并、配置叠加(非敏感字段)、API响应聚合。

2. + 运算符|保留左侧优先

PHP的+运算符合并数组时:以左侧数组为基准,仅添加右侧数组中不存在的键。即:**先存在者优先**。

示例:

$a1 = ['a' => 1, 'b' => 2];
$a2 = ['b' => 3, 'c' => 4];
$result = $a1 + $a2;
// 结果:['a' => 1, 'b' => 2, 'c' => 4] —— b未被覆盖

对索引数组同样生效(按索引位置判断是否存在):

$a1 = [0 => 'x', 2 => 'z'];
$a2 = [1 => 'y', 2 => 'w'];
$result = $a1 + $a2;
// 结果:[0 => 'x', 2 => 'z', 1 => 'y'] —— 注意索引2的值未被覆盖

关键差异:array_merge()会重置索引,而+运算符严格保留原始索引。这在需要保留原始顺序的场景(如分页数据拼接)中至关重要。

典型陷阱:开发者常误以为+是“拼接”,实际是“补充缺失键”。若需覆盖,应交换左右顺序。

3. array_merge_recursive()|深度递归合并

当数组元素本身是数组时,array_merge()会直接覆盖整个子数组,而array_merge_recursive()会递归合并子数组:

$config1 = ['db' => ['host' => 'localhost', 'port' => 3306]];
$config2 = ['db' => ['port' => 3307, 'user' => 'root']];
$result = array_merge_recursive($config1, $config2);

重要特性:当键名冲突且值为数组时,会将两个值合并为新数组(而非覆盖)。这可能导致意外的嵌套层级(如port从int变为array)。

解决方案:若需覆盖而非合并,应先判断类型:

function safe_merge_recursive($a1, $a2) {
    foreach ($a2 as $key => $value) {
        if (is_array($value) && isset($a1[$key]) && is_array($a1[$key])) {
            $a1[$key] = array_merge_recursive($a1[$key], $value);
        } else {
            $a1[$key] = $value;
        }
    }
    return $a1;
}

适用场景:多源配置合并(如主配置+环境变量)、多级分类树整合。

4. array_replace()|精准覆盖替换

array_replace()与array_merge()类似,但对**索引数组保留原始索引**,且仅替换已存在的键:

$a1 = ['a' => 1, 'b' => 2, 0 => 'x'];
$a2 = ['b' => 3, 'c' => 4, 0 => 'y'];
$result = array_replace($a1, $a2);
// 结果:['a' => 1, 'b' => 3, 0 => 'y', 'c' => 4]

对比array_merge()的结果:

$result = array_merge($a1, $a2);
// 结果:['a' => 1, 'b' => 3, 0 => 'y', 1 => 'x', 'c' => 4]

关键差异:array_replace()不重置索引,且新增键时按右侧数组顺序追加。

进阶技巧:可链式调用实现多源覆盖:

$final = array_replace($defaults, $user_prefs, $overrides);

执行顺序:defaults → user_prefs → overrides(后者覆盖前者)。

5. 循环遍历|完全自定义逻辑

当内置函数无法满足特殊需求时(如自定义冲突策略),可手动遍历:

$merged = [];
foreach ($a1 as $key => $val) {
    $merged[$key] = $val;
}
foreach ($a2 as $key => $val) {
    // 自定义逻辑:仅当键不存在或值为null时覆盖
    if (!isset($merged[$key]) || $val === null) {
        $merged[$key] = $val;
    } elseif (is_array($val) && is_array($merged[$key])) {
        $merged[$key] = array_merge($merged[$key], $val);
    }
}

优势:完全控制合并逻辑,适合复杂业务规则(如权限系统中的“高权限覆盖低权限”)。

性能提示:PHP 7.4+中,使用foreach比array_reduce()快约15%,大数组场景下差异更明显。

php 两个数组合并|方法对比与选择指南

方法 索引数组行为 关联数组冲突 递归支持 性能(10k元素)
array_merge() 重置索引 后覆盖前 ❌ 不支持 12ms
+ 运算符 保留原始索引 先存在者优先 ❌ 不支持 8ms
array_merge_recursive() 重置索引 子数组递归合并 ✅ 支持 18ms
array_replace() 保留原始索引 后覆盖前 ❌ 不支持 10ms
循环遍历 完全自定义 完全自定义 ✅ 可实现 14ms

选择决策树

遇到合并需求时,按以下步骤快速决策:

  1. 是否需要递归合并子数组? → 是 → array_merge_recursive()(注意类型陷阱)
  2. 是否需保留原始索引? → 是 → +运算符 或 array_replace()(前者覆盖前者,后者覆盖后者)
  3. 是否需自定义冲突策略? → 是 → 循环遍历
  4. 其他情况 → array_merge()

php 两个数组合并|实战案例解析

案例1:用户配置合并(防止越权)

需求:默认配置 + 用户自定义配置,但敏感字段(如role)禁止用户覆盖。

$defaults = ['theme' => 'dark', 'lang' => 'zh', 'role' => 'user'];
$user_prefs = ['theme' => 'light', 'lang' => 'en', 'role' => 'admin'];
// 正确做法:先合并,再保护敏感字段
$merged = array_merge($defaults, $user_prefs);
$merged['role'] = $defaults['role']; // 强制还原默认值
// 或使用循环过滤
foreach ($user_prefs as $key => $val) {
    if (!in_array($key, ['role', 'password'])) {
        $merged[$key] = $val;
    }
}

反例警示:直接$merged = $defaults + $user_prefs会导致role保持为'user',用户无法修改语言,体验极差。

案例2:分页数据拼接

场景:从缓存和数据库分别获取第1页、第2页数据,需按原始顺序合并。

$page1 = [0 => ['id' => 1], 1 => ['id' => 2]];
$page2 = [0 => ['id' => 3], 1 => ['id' => 4]];
// 错误:array_merge会重置索引 → [0,1,2,3]
$wrong = array_merge($page1, $page2);
// 正确:+运算符保留索引
$correct = $page1 + $page2;
// 结果:[0=>[id=1], 1=>[id=2], 0=>[id=3], 1=>[id=4]] —— 仍需后续处理

实际解决方案:使用索引偏移:

$offset = count($page1);
foreach ($page2 as $item) {
    $page1[$offset++] = $item;
}
// 结果:[0,1,2,3]且顺序正确

案例3:多环境配置合并

场景:base.php + dev.php + local.php,后者覆盖前者。

$base = require 'base.php';
$dev = require 'dev.php';
$local = require 'local.php';
// 使用array_replace支持链式覆盖
$config = array_replace($base, $dev, $local);

陷阱:若$base['db']['port']为int,而$dev['db']['port']为null,array_replace()会直接覆盖为null,导致连接失败。

修复方案:

function merge_config($a, $b) {
    foreach ($b as $k => $v) {
        if (is_array($v) && isset($a[$k]) && is_array($a[$k])) {
            $a[$k] = merge_config($a[$k], $v);
        } elseif ($v !== null || !isset($a[$k])) {
            $a[$k] = $v;
        }
    }
    return $a;
}

php 两个数组合并|高频避坑指南

陷阱1:空数组的陷阱

当合并空数组时,array_merge()会重置索引,但+运算符可能返回空数组:

$a = [];
$b = ['key' => 'val'];
$result1 = array_merge($a, $b); // ['key' => 'val']
$result2 = $a + $b;             // ['key' => 'val']
$result3 = $b + $a;             // ['key' => 'val'] —— 相同

但若$a = [0 => 'x'],$b = []:

$a + $b = [0 => 'x']
$b + $a = [0 => 'x'] —— 一致

结论:空数组场景下两者行为一致,但需警惕非空数组的索引差异。

陷阱2:引用数组的副作用

合并数组时,若原数组含引用,PHP会创建新引用:

$a = ['x' => &$val];
$b = ['x' => 'new'];
$result = array_merge($a, $b);
// 修改$result['x']不会影响$val —— 引用被断开

解决方案:合并前断开引用:

$a = array_map(function($v) { return $v; }, $a);

陷阱3:对象转数组的坑

直接合并对象数组时,array_merge()会转换为关联数组:

$obj1 = (object)['a' => 1];
$obj2 = (object)['b' => 2];
$result = array_merge((array)$obj1, (array)$obj2);
// 结果:['a' => 1, 'b' => 2]

但若对象含私有属性,键名会带类名前缀(如ClassName),导致解析失败。

推荐方案:使用json_encode/decode标准化:

$a = json_decode(json_encode($obj1), true);
$b = json_decode(json_encode($obj2), true);
$result = array_merge($a, $b);

php 两个数组合并|性能优化策略

基准测试数据(PHP 8.1)

方法 100元素 1k元素 10k元素
array_merge() 0.02ms 0.18ms 12.4ms
+ 运算符 0.01ms 0.12ms 8.2ms
array_merge_recursive() 0.05ms 0.45ms 18.6ms

优化建议