Lodash merge与assign在JS对象合并中的行为差异

作者:纸飞机时间:2026-11-19 23:21:34浏览:635

深入对比Lodash中merge与assign在JavaScript对象合并中的核心行为差异,涵盖嵌套对象处理、数组索引合并、undefined覆盖及性能选型指南。

在 JavaScript 开发中,对象合并是组装配置参数、合并接口响应及管理应用状态的高频操作。Lodash 提供的 _.assign 与 _.merge 是两种最常用的合并工具函数。简要结论是:_.assign 执行的是浅合并(Shallow Assignment),其底层逻辑与原生 Object.assign 一致,仅复制第一层属性的引用;而 _.merge 执行的是递归深合并(Deep Merging),会向下递归遍历普通对象与数组,保留两端未冲突的深层结构。两者的实质差异主要集中在嵌套对象保留程度、数组处理策略、undefined 值的改写逻辑以及执行性能四个方面。

一、核心机制:浅合并与深合并的执行逻辑

理解两者的第一步是明确“属性分配”与“递归融合”在内存引用层面的不同表现。

_.assign(object, [sources]) 遍历源对象自身的全部可枚举属性,将对应的值直接赋值给目标对象。如果某个属性的值是一个嵌套对象或数组,_.assign 只会拷贝该对象在堆内存中的内存引用,而不会进入该对象内部去对比或合并其子属性。这意味着,一旦源对象包含了同名的嵌套属性,目标对象原有的整个子对象将被彻底覆盖替换。

_.merge(object, [sources]) 则采用递归遍历机制。遇到嵌套属性时,它会判断目标属性值与源属性值是否同为普通对象(Plain Object)或数组。如果是,它不会直接替换引用,而是在保持现有结构的基础上,递归比对并融合各自的键值对。

Lodash merge与assign在JS对象合并中的行为差异
图 1:_.assign 浅层引用覆盖与 _.merge 深度递归融合的内部机制对比

下面的代码示例展示了在同一组包含多层配置的对象输入下,两个方法产生的不同结果:

const _ = require('lodash');

// 基础默认配置
const defaultConfig = {
  protocol: 'https',
  server: {
    host: 'api.example.com',
    port: 443,
    timeout: 3000
  }
};

// 用户传入的局部定制配置
const userConfig = {
  server: {
    timeout: 8000
  }
};

// 1. 使用 _.assign 浅合并
const assignResult = _.assign({}, defaultConfig, userConfig);
console.log('assign 结果:', JSON.stringify(assignResult.server));

// 2. 使用 _.merge 深合并
const mergeResult = _.merge({}, defaultConfig, userConfig);
console.log('merge 结果:', JSON.stringify(mergeResult.server));
示例输出:
assign 结果: {"timeout":8000}
merge 结果: {"host":"api.example.com","port":443,"timeout":8000}

在 _.assign 的结果中,server 属性被 userConfig.server 整体替换,导致 host 与 port 丢失;而在 _.merge 中,程序保留了未在 userConfig 中声明的 host 和 port,仅精准更新了目标 timeout。

二、_.merge 的递归遍历与属性决策流程

为了保证合并过程的确定性与安全性,_.merge 在遍历属性时遵循一套严格的内部推导流程。它不会盲目递归所有类型,而是根据键值的运行时类型决定处理分支。

在处理源对象的每一个属性键时,Lodash 会依次执行以下四个步骤:

  1. 检查 undefined 值:若源属性的值为 undefined,直接跳过处理,保留目标对象中的原值。
  2. 检查普通对象(Plain Object):若目标值与源值均为普通对象,则递归进入子层继续执行合并流程。
  3. 检查数组结构(Array):若目标值与源值均为数组,则依据元素所在的数组下标索引,逐项递归对齐合并。
  4. 标量与特殊对象覆盖:对于原始数据类型(数字、字符串、布尔值)、函数、Date 对象或自定义类实例,直接执行赋值覆盖。
Lodash merge与assign在JS对象合并中的行为差异
图 2:_.merge 属性解析与合并决策流程图

三、关键边界场景的行为差异

除了常规的嵌套对象合并外,在处理特殊数据结构或边缘值时,_.assign 与 _.merge 的行为规则截然不同,稍有不慎便会导致业务逻辑异常。

Lodash merge与assign在JS对象合并中的行为差异
图 3:_.assign 与 _.merge 核心边界场景行为矩阵

1. 数组合并策略:整体替换 vs 索引级递归(易错陷阱)

在大多数业务开发者的直觉中,“深合并”应当将两个数组拼接(Concat)或完全去重联合。然而,_.merge 对数组的处理是按索引递归合并,而非追加或拼接。

对于数组下标 0 的位置,_.merge 会将 source[0] 合并到 target[0];若该位置存放的是对象,它还会继续深度融合对象内部的键。如果源数组长度短于目标数组,目标数组超出部分的元素依然会被完整保留。而 _.assign 则将数组视为普通的标量引用,直接用源数组替换目标数组。

const target = { tags: ['javascript', 'web', 'node'] };
const source = { tags: ['typescript'] };

console.log('assign 数组合并:', _.assign({}, target, source).tags);
console.log('merge 数组合并:', _.merge({}, target, source).tags);
示例输出:
assign 数组合并: [ 'typescript' ]
merge 数组合并: [ 'typescript', 'web', 'node' ]
警惕数组索引合并陷阱
在上面的 _.merge 示例中,源数组只有 1 个元素 'typescript',它仅仅覆盖了目标数组索引为 0 的位置,而目标数组的 'web' 和 'node'(索引 1 与 2)被保留了下来,最终产生了 ['typescript', 'web', 'node'] 的混合数据。如果期望实现“数组整体替换”或“去重追加”,请不要直接使用 _.merge,而应使用后文介绍的 _.mergeWith。

2. undefined 属性的处理:覆盖 vs 忽略

在表单重置或接口补丁场景中,传入值为 undefined 的键是常见情况。两个函数的处理哲学在此处完全相反:

  • _.assign:严格按照 JavaScript 属性赋值规范,将属性设为 undefined,目标对象的初始值被冲掉。
  • _.merge:遵循保护默认值的策略,源对象中明确为 undefined 的属性会被自动忽略,目标对象上的初始值保持不变。
const defaultSettings = { theme: 'dark', notify: true };
const patch = { theme: undefined, notify: false };

console.log('assign 遇到 undefined:', _.assign({}, defaultSettings, patch));
console.log('merge 遇到 undefined:', _.merge({}, defaultSettings, patch));
示例输出:
assign 遇到 undefined: { theme: undefined, notify: false }
merge 遇到 undefined: { theme: 'dark', notify: false }

需要特别注意:null 与 undefined 不同。在 _.merge 中,null 被视为有效的具体值,它会正常覆盖目标对象的现有属性。

3. 原型属性(Inherited Properties)的拷贝范围

_.assign 只拷贝源对象自身(Own)的可枚举属性,这与原生 Object.keys() 以及 Object.assign() 保持一致。如果源对象的原型链上定义了可枚举属性,_.assign 会直接略过。

_.merge 则不仅检索源对象的自身属性,还会遍历源对象原型链上的继承可枚举属性,并将它们合并为目标对象的自身属性。因此在处理由自定义类实例化出的对象时,需确认是否要将原型属性一并提取并融合。

四、进阶方案:使用 _.mergeWith 解决数组与特殊类型冲突

针对 _.merge 默认按索引合并数组所带来的非预期行为,Lodash 提供了定制器版本 _.mergeWith。该函数接受一个自定义回调函数 customizer(objValue, srcValue, key, object, source)。当回调返回 undefined 时,保持默认深合并逻辑;当返回具体值时,则以返回值作为最终合并结果。

以下是项目中最常见的实用模式:在深度合并对象的同时,对数组执行整块替换或去重拼接:

const targetObj = {
  api: {
    endpoints: ['/users', '/roles'],
    rateLimit: { max: 100 }
  }
};

const sourceObj = {
  api: {
    endpoints: ['/auth'],
    rateLimit: { windowMs: 60000 }
  }
};

// 定制器:遇到数组时直接用源数组替换,不按索引融合
function customizer(objValue, srcValue) {
  if (_.isArray(objValue)) {
    return srcValue; // 整体替换数组
  }
}

const merged = _.mergeWith({}, targetObj, sourceObj, customizer);
console.log('mergeWith 替换数组结果:', JSON.stringify(merged));
示例输出:
mergeWith 替换数组结果: {"api":{"endpoints":["/auth"],"rateLimit":{"max":100,"windowMs":60000}}}

借助 _.mergeWith,既完整继承了深层 rateLimit 配置,又彻底规避了 endpoints 数组中可能产生的脏索引数据。

五、性能考量与选型决策指南

在实际项目架构中,合并函数的选择需要权衡开发便捷度与运行开销。

_.assign 的本质是单层循环属性拷贝,现代 V8 引擎对其内联缓存(Inline Caches)支持极好,基准运行耗时通常在纳秒级别。而 _.merge 需要进行原型链判断、深层栈式递归与循环引用防护(通过 Stack 结构记录已遍历对象),其计算开销远高于 _.assign。在高频触发的渲染循环、海量数据迭代或纯扁平键值对拼接场景下,过度使用 _.merge 会引发明显的 CPU 占用。

Lodash merge与assign在JS对象合并中的行为差异
图 4:JavaScript 对象合并方案选型决策指南

各合并方案的具体对比维度归纳如下:

技术方案 适用数据结构 合并深度 数组合并表现 性能开销
对象展开运算符 { ...a, ...b } 单层扁平对象 浅拷贝(1层) 覆盖引用 极低(引擎内建指令)
原生 Object.assign 单层扁平对象 浅合并(1层) 覆盖引用 极低(零额外依赖)
Lodash _.assign 单层扁平对象 浅合并(1层) 覆盖引用 极低(与原生类似)
Lodash _.merge 多层嵌套普通对象 递归深合并 按索引递归合并 中等(递归遍历与类型判定)
Lodash _.mergeWith 含数组的复杂配置树 自定义可控深合并 可通过定制器任意指定 中等(含回调函数开销)

六、实践总结与排查清单

在日常开发中选用对象合并方案时,可以对照以下清单进行快速自检:

  • 明确层级深度:如果待合并的对象仅有单层扁平键值对,优先选用对象展开语法 { ...target, ...source } 或 Object.assign,无需引入第三方库函数。
  • 检查配置重写意图:若是合并具有多级树状结构的系统配置,且期望保留默认子项,使用 _.merge。
  • 审视数组字段:一旦对象树中含有数组字段,且业务期望“传入新数组即全量替换旧数组”,必须改用 _.mergeWith 并通过判断 _.isArray 返回源数组,防止索引对位残留脏数据。
  • 核对 undefined 意图:如果业务需要显式通过 undefined 清空已有配置项,_.merge 会将其自动过滤,此时应使用 _.assign 或在 _.mergeWith 中显式处理。
作者最新文章
相关文章
更多