JS对象合并:展开运算符与Object.assign的区别及用法

作者:闭包旅人时间:2026-11-17 15:01:39浏览:573

深入解析JavaScript中展开运算符(...)与Object.assign()在对象合并时的核心区别、底层原理、运行机制及常见边界场景,帮助开发者准确选择最适合的合并方案。

合并 JavaScript 对象时,展开运算符(...)与 Object.assign() 都能将源对象的自身可枚举属性复制到目标对象中,且底层均为浅拷贝。两者的本质差异在于:展开运算符始终生成全新对象并使用属性定义([[DefineOwnProperty]])机制,绝不触发目标 Setter;而 Object.assign() 会原地修改第一个传入的目标对象,并使用属性赋值([[Set]])机制,因而会触发目标对象既有的 Setter。在绝大多数日常开发中,展开运算符凭借简洁的语法和天然的不可变性成为首选;而在需要就地修改既有对象或兼容旧运行时时,Object.assign() 则是不可替代的标准方法。
JS对象合并:展开运算符与Object.assign的区别及用法
图 0:展开运算符与 Object.assign() 的定位与核心特征对比

一、基础语法与常规用法

在 ES2015(ES6)引入 Object.assign() 之前,合并对象常借助第三方库或自定义循环。随后 ES2018 进一步将对象的展开运算(Object Spread Properties)纳入标准规范,让对象合并变得更加轻量直观。

1. 展开运算符的基础用法

展开运算符通过三点语法 ... 解构现有对象的自身可枚举属性,将其直接铺在全新的对象字面量中。同名属性遵循“后出现的覆盖先出现的”顺序规则:

// 基础合并与属性覆盖
const baseConfig = { theme: 'light', timeout: 3000, debug: false };
const userConfig = { theme: 'dark', debug: true };

const merged = { ...baseConfig, ...userConfig };

console.log(merged);
// 输出示例: { theme: 'dark', timeout: 3000, debug: true }

在这段代码中,merged 是一个在堆内存中独立分配的新对象,原有对象 baseConfig 和 userConfig 保持不变,符合函数式编程提倡的数据不可变(Immutability)原则。

2. Object.assign() 的基础用法

Object.assign(target, ...sources) 接收一个目标对象 target 和一个或多个源对象 sources。它的作用是将所有源对象的自身可枚举属性逐个拷贝到目标对象中,最后返回目标对象的引用:

// 原地修改目标对象
const target = { a: 1 };
const source = { b: 2, c: 3 };

const result = Object.assign(target, source);

console.log(result === target); 
// 输出示例: true (返回值就是 target 本身)
console.log(target); 
// 输出示例: { a: 1, b: 2, c: 3 } (target 自身已被修改)

如果希望使用 Object.assign() 获得一个新对象而不污染既有对象,常见做法是将第一个参数设置为空对象字面量 {}:

const safeCopy = Object.assign({}, baseConfig, userConfig);

二、核心共性:浅拷贝与引用共享

一种容易混淆的认识是“展开运算符比 Object.assign 更高级,因此能处理深层嵌套”。这种说法是不正确的。无论使用展开运算符还是 Object.assign(),它们执行的都是标准的浅拷贝(Shallow Copy)。

浅拷贝意味着:如果源对象的某个属性值是基础类型(如数字、字符串、布尔值),拷贝的是该值的直接副本;但如果属性值是复杂对象、数组或函数,拷贝的仅仅是该对象的内存地址指针,新旧对象将共享同一份内部数据。

const original = {
  id: 101,
  meta: { role: 'admin' }
};

const copyA = { ...original };
const copyB = Object.assign({}, original);

// 修改第一层基础类型:彼此独立,互不影响
copyA.id = 202;
console.log(original.id); // 输出示例: 101

// 修改第二层嵌套对象:发生连带影响!
copyB.meta.role = 'editor';
console.log(original.meta.role); // 输出示例: 'editor'
console.log(copyA.meta.role);    // 输出示例: 'editor'
JS对象合并:展开运算符与Object.assign的区别及用法
图 1:展开运算符与 Object.assign() 的浅拷贝内存引用结构
提醒:如需深度独立合并,勿用浅拷贝语法

如果对象内部存在深层嵌套,且要求拷贝后绝对互不影响,请使用现代浏览器与 Node.js 原生支持的 structuredClone() 进行完全深拷贝,或者针对特定配置项递归合并。

三、底层机制差异:属性定义(Define)与属性赋值(Set)

虽然两者在绝大多数普通属性的拷贝上输出相同的结果,但它们的规范底层调用截然不同,这在带有访问器属性(Getter/Setter)或只读属性的对象上会表现出显著区别。

1. 展开运算符使用 [[DefineOwnProperty]]

展开运算符在装配对象字面量时,对每个键值对调用的是规范内部方法 [[DefineOwnProperty]]。它直接在刚创建的新对象上定义自身的普通数据属性。

  • 由于新对象是全新生成的空字面量,其原型链不会包含干扰属性。
  • 即使新对象的原型链后续挂载了 Setter,展开操作在生成字面量时也绝不会触发任何 Setter。

2. Object.assign() 使用 [[Set]]

Object.assign() 遍历源对象的可枚举属性后,对目标对象调用的是内部方法 [[Set]],即相当于执行普通赋值语句 target[key] = value。

  • 如果 target 对象自身或其原型链上定义了同名属性的 Setter,Object.assign() 将直接调用该 Setter 函数,而不是给 target 新建普通数据属性。
  • 如果 target 上的同名属性是只读属性(writable: false),赋值将被拒绝,在严格模式下会直接抛出 TypeError: Cannot assign to read only property。
// 对比测试:目标对象具有 Setter 时的表现差异
let setterCallCount = 0;

const targetWithSetter = {
  set count(val) {
    setterCallCount += val;
  }
};

const sourceData = { count: 5 };

// 情况 A:Object.assign 会调用目标对象的 setter
Object.assign(targetWithSetter, sourceData);
console.log(setterCallCount); 
// 输出示例: 5 (setter 被触发调用,count 属性本身并没有变成普通数值)

// 情况 B:展开运算符创建全新对象并直接定义属性
const spreadResult = { ...targetWithSetter, ...sourceData };
console.log(setterCallCount); 
// 输出示例: 5 (并未增加!没有触发 setter)
console.log(spreadResult.count); 
// 输出示例: 5 (作为普通自身数据属性写入)
JS对象合并:展开运算符与Object.assign的区别及用法
图 2:[[Set]] 赋值操作与 [[DefineOwnProperty]] 属性定义的流程分歧

3. 源对象中 Getter 的读取共性

值得强调的是,在读取源对象时,展开运算符和 Object.assign() 是一致的:它们都会执行源对象上的 Getter 访问器函数,并将 Getter 计算后返回的具体值拷贝过去。拷贝完成后,新对象中的对应属性变成了普通数据属性,原本的 Getter 函数本身并不会被复制保留。

const sourceObj = {
  firstName: 'Ada',
  lastName: 'Lovelace',
  get fullName() {
    return `${this.firstName} ${this.lastName}`;
  }
};

const cloned = { ...sourceObj };
console.log(Object.getOwnPropertyDescriptor(cloned, 'fullName'));
// 输出示例: { value: 'Ada Lovelace', writable: true, enumerable: true, configurable: true }
// 原本的 getter 变成了普通的数据属性值

四、原型链与不可枚举属性的处理边界

合并操作常用于混合数据,但在涉及类实例或复杂数据结构时,必须明确两者的属性过滤规则:

  • 原型链属性均被忽略:两者都只拷贝对象自身(Own)的属性,不会沿着 __proto__ 原型链往上拷贝继承的方法或属性。
  • 不可枚举属性均被忽略:通过 Object.defineProperty() 设置为 enumerable: false 的属性,两者都不会进行拷贝。
  • Symbol 属性均被支持:以 Symbol 作为键的自身可枚举属性,两者都会正常拷贝。
  • 生成对象的原型归属:展开运算符 { ...obj } 总是以 Object.prototype 为原型创建普通对象。如果 obj 是某个类的实例(例如 class User),直接展开后得到的将是纯 Object,丢失该类原型上的实例方法。

五、原始类型与异常值的处理差异

在实际编码中,入参往往可能携带 null、undefined 或基本数据类型(如数字、字符串)。两者的容错行为存在细微差异:

1. 展开运算符对原始类型的行为

在对象字面量中展开基础类型时,引擎会安全地处理:

  • 展开 null 或 undefined:直接静默跳过,不报任何错误,也不会向对象中添加任何键值。
  • 展开数字或布尔值:数字和布尔包装对象没有自身可枚举属性,因此同样被静默跳过。
  • 展开字符串:字符串具备自身索引属性,会被拆解为字符键值对,例如 { ...'cat' } 得到 { 0: 'c', 1: 'a', 2: 't' }。

2. Object.assign() 对原始类型的行为

  • 首个参数(Target)为 null/undefined:会直接抛出 TypeError: Cannot convert undefined or null to object,因为必须有具体的对象承载修改。
  • 首个参数为基本类型:会被临时装箱为对应的包装对象(如数字转为 Number 对象),并返回该包装对象。
  • 后续参数(Source)为 null/undefined 或基本类型:与展开运算符类似,后续源对象中的 null 与 undefined 会被安全跳过,字符串源对象会被拆解并写入目标。
JS对象合并:展开运算符与Object.assign的区别及用法
图 3:对象合并场景判断与选型路径

六、综合对比与核心总结

为了直观梳理两者的核心技术规格与差异边界,下表及图示从语法形式、底层原理、返回值、副作用与适用边界进行了全维度对照:

对比维度 展开运算符 { ...a, ...b } Object.assign(target, ...sources)
语法形式 字面量表达式(Spread Syntax) 内置全局方法调用(Function Call)
返回值与副作用 始终返回全新普通对象,无副作用 返回第一个入参 target,原地修改
底层写入操作 [[DefineOwnProperty]] 属性定义 [[Set]] 属性赋值
Setter 行为 绝不触发目标 Setter 若 target 含有 Setter,会被触发调用
Getter 行为 读取 source 时调用,拷贝具体计算值 读取 source 时调用,拷贝具体计算值
拷贝深度 浅拷贝(嵌套对象共享引用) 浅拷贝(嵌套对象共享引用)
原型与继承 忽略原型链,只拷贝自身可枚举属性 忽略原型链,只拷贝自身可枚举属性
首参数为 null/undefined 安全,静默跳过无报错 抛出 TypeError 运行时异常
JS对象合并:展开运算符与Object.assign的区别及用法
图 4:展开运算符与 Object.assign() 全景技术规格总结矩阵

综上所述,展开运算符与 Object.assign() 并非简单的语法糖替代关系。在现代前端工程与日常业务逻辑中,推荐优先使用展开运算符 { ...defaults, ...options } 来组织合并逻辑;而当面对需要原地扩充对象、保留特定对象引用或兼容遗留老旧运行环境时,Object.assign() 依然是规范可靠的标准工具。

作者最新文章
相关文章
更多