掌握JavaScript：Object.assign()合并对象的技巧

技术文档

本文还有配套的精品资源，点击获取

简介： Object.assign() 是JavaScript中的实用工具函数，用于将多个源对象的属性浅拷贝并合并到一个目标对象中。该方法遵循后覆盖原则，当源对象属性冲突时，以最后出现的源对象的属性为准。本教程将深入探讨 Object.assign() 的使用细节、局限性以及在实际开发中的多种应用场景。

1. JavaScript中Object.assign()函数的介绍

JavaScript语言中的 Object.assign() 函数是一个非常实用的工具，它用于将一个或多个源对象的所有可枚举属性复制到目标对象中。这个函数在对象属性合并、默认参数设置以及对象初始化等方面有着广泛的应用，可以有效地简化代码并提高开发效率。接下来，我们将深入了解 Object.assign() 的基础用法、数据类型处理、后覆盖原则、浅拷贝局限性及应对措施、以及它在不同编程场景中的应用和代码可读性、可维护性的提升建议。随着章节的深入，我们将通过实例演示和代码分析，揭示 Object.assign() 如何帮助开发者解决实际编程中遇到的问题。

2. 创建新对象并合并属性的浅拷贝过程

2.1 Object.assign()的基础用法

2.1.1 合并对象的基本语法

Object.assign() 是 JavaScript 中用于合并两个或多个对象的一个方法，它将所有可枚举的自有属性从一个或多个源对象复制到目标对象，并返回修改后的目标对象。此函数通常用于对象属性的合并，尤其是当需要创建具有特定默认属性值的新对象时。

其基本语法如下：

Object.assign(target, ...sources);

target - 目标对象，其他对象的属性将被复制到这个对象上。
sources - 源对象，一个或多个包含要被复制的属性的对象。

下面是一个简单的例子：

const target = { a: 1, b: 2 };const source = { b: 4, c: 5 };const returnedTarget = Object.assign(target, source);console.log(target); // { a: 1, b: 4, c: 5 }console.log(returnedTarget); // { a: 1, b: 4, c: 5 }

在这个例子中， source 对象的属性被复制到 target 对象中。 Object.assign() 方法返回的是修改后的 target 对象。

2.1.2 属性复制的执行机制

属性复制执行机制涉及几个重要步骤：

确定属性可枚举性 ： Object.assign() 只会复制源对象上可枚举的属性（通过 Object.keys() 方法可枚举的属性）。
识别同名属性 ：如果目标对象和源对象有同名属性，源对象的属性值会覆盖目标对象中的同名属性。
属性值类型 ：复制的是属性值，如果属性值是引用类型（如对象），则复制的是引用地址而非对象本身。
返回值 ： Object.assign() 返回目标对象本身，也就是经过修改后的那个对象。

让我们深入理解这一点：

const source1 = { a: 1 };const source2 = { b: 2 };const target = { a: 3, c: 4 };const newTarget = Object.assign({}, target, source1, source2);console.log(newTarget); // { a: 1, c: 4, b: 2 }

在这个例子中， target 对象被复制到一个新对象中（作为第一个参数），然后 source1 和 source2 对象的属性依次被复制，覆盖了同名属性。

2.2 合并对象时的数据类型处理

2.2.1 基本数据类型的合并效果

Object.assign() 处理基本数据类型（如字符串、数字、布尔等）时，会将其值从源对象复制到目标对象。

const target = { a: \'hello\' };const source = { a: \'world\' };Object.assign(target, source);console.log(target); // { a: \'world\' }

此处， source 对象中的字符串值 \'world\' 覆盖了 target 对象中的 \'hello\' 。

2.2.2 引用数据类型的合并效果

当涉及引用数据类型时（如数组、对象）， Object.assign() 将复制引用而非实际的对象。这意味着源对象和目标对象中的引用数据类型属性实际上指向同一个地址。

const target = { a: { x: 1 } };const source = { a: { y: 2 } };Object.assign(target, source);console.log(target); // { a: { y: 2 } }console.log(target.a === source.a); // true

我们看到，虽然 target 对象中的 a 属性看起来被 source 对象中的 a 属性覆盖了，实际上 target.a 和 source.a 都指向同一个对象。因此，对 target.a 的任何修改都会反映在 source.a 上。

2.2.3 Object.assign() 对数组的操作

Object.assign() 对数组执行时，会将其视作对象处理。它会复制数组中的元素作为属性，其中数组索引作为属性名。

const target = { 0: \'a\', 1: \'b\', length: 2 };const source = { 1: \'c\', 2: \'d\', length: 3 };const result = Object.assign(target, source);console.log(result);// { \'0\': \'a\', \'1\': \'c\', \'2\': \'d\', length: 3 }

数组的 length 属性和索引都会被复制。但是需要注意，这不会改变数组的类型或者创建一个新数组，它仅仅是将数组视为对象并按照对象属性进行复制。

2.2.4 特殊类型Symbol的处理

在JavaScript中， Symbol 是一种特殊的且唯一的类型，它允许你创建不可枚举的属性名称。 Object.assign() 处理 Symbol 类型时，如果 Symbol 的属性已被定义在源对象上，那么它也会被复制。

const symbol1 = Symbol(\'symbol1\');const symbol2 = Symbol(\'symbol2\');const source = { [symbol1]: \'source value\' };const target = { [symbol1]: \'target value\', [symbol2]: \'target value2\' };Object.assign(target, source);console.log(target[symbol1]); // \'source value\'console.log(target[symbol2]); // \'target value2\'

2.2.5 Object.assign() 浅拷贝的特例处理

Object.assign() 是一个浅拷贝操作。当属性值为对象时，复制的是引用地址而非对象本身。如果需要进行深拷贝，不能使用 Object.assign() ，而应使用其他方法（例如递归复制或者使用 JSON.parse(JSON.stringify(object)) ）。

2.2.6 总结

Object.assign() 是一个非常灵活和有用的方法，尤其在需要合并对象或复制对象属性时。但开发者必须了解其浅拷贝的限制，并且在涉及引用数据类型时格外小心。在实际使用中，理解其数据类型处理的差异有助于我们更好地控制对象属性的合并行为，避免不必要的错误。

3. 后覆盖原则的应用

3.1 后覆盖原则的定义与作用

3.1.1 后覆盖原则的含义

在使用 Object.assign() 进行对象合并时，后覆盖原则是一个重要的概念。它的核心思想是指，在一个合并操作中，如果遇到同名属性，那么后续对象中的属性值将会覆盖前面对象中的属性值。这种行为保证了对象属性合并的最后表现与期望的一致性，也即“后入为主”。

举个简单的例子：

const obj1 = { a: 1, b: 2 };const obj2 = { b: 3, c: 4 };const result = Object.assign(obj1, obj2);

在这个例子中， result 对象最终的输出将是 { a: 1, b: 3, c: 4 } 。注意 b 属性从 obj1 的 2 被覆盖为了 obj2 的 3 ，这是后覆盖原则的直接体现。

3.1.2 后覆盖原则在合并中的表现

后覆盖原则在多个对象合并时尤为明显，尤其是当这些对象存在相同属性的时候。在 Object.assign() 合并方法中，这些对象会按照传递的顺序依次进行合并。因此，最后一个对象的相同属性值会最终决定该属性的值。

const obj1 = { a: 1, b: 2 };const obj2 = { b: 3, c: 4 };const obj3 = { a: 5, d: 6 };const result = Object.assign({}, obj1, obj2, obj3);

结果 result 将是 { a: 5, b: 3, c: 4, d: 6 } 。 a 属性最终值为 5 ，因为 obj3 是最后一个传递的对象。同样的， b 属性的值为 3 ，因为 obj2 紧随其后。

3.2 后覆盖原则的实际应用场景

3.2.1 解决属性冲突的策略

在实际开发中，后覆盖原则能够有效地帮助开发者解决属性冲突的问题。当多个对象合并时，通过控制合并的顺序，可以很容易地实现对属性值的控制。

例如，在Web开发中，我们可能需要将多个配置对象合并到一个设置对象中。通过后覆盖原则，我们可以首先合并通用的默认设置，然后再覆盖特定环境下的设置。

const defaults = { volume: 10, brightness: 10 };const environment = { volume: 8 };const userPreferences = { brightness: 8, contrast: 5 };const settings = Object.assign({}, defaults, environment, userPreferences);

这里 settings 将为 { volume: 8, brightness: 8, contrast: 5 } 。可以看到用户偏好设置覆盖了之前的 brightness 值，而环境设置则覆盖了 volume 值。

3.2.2 处理顺序依赖的案例分析

后覆盖原则在处理对象合并时，尤其是顺序依赖的情况时非常有用。在一些场景下，对象属性的最终值依赖于其他对象属性的值。因此，必须确保按照正确的顺序合并对象，以满足这种依赖关系。

举例来说，在一个复杂的表单验证系统中，可能有不同的验证规则对象需要合并，以形成最终的验证规则集。

const baseRules = { required: true, minLength: 5 };const extendedRules = { maxLength: 10 };const customRules = { regex: /^[A-Z]+$/ };// 必须先应用基础规则，然后是扩展规则，最后是自定义规则const finalRules = Object.assign({}, baseRules, extendedRules, customRules);

在这个例子中，先应用 baseRules 确保了基础验证逻辑的完整性，然后添加了 extendedRules 来进行进一步的限制，最后是 customRules 来实现特定场景下的验证。这样的顺序保证了逻辑的正确性，也遵循了后覆盖原则。

在实际开发中，通过遵循后覆盖原则，我们可以确保对象合并逻辑的正确性和一致性，避免因属性覆盖不当导致的错误和混淆。

4. 浅拷贝的局限性及应对措施

4.1 浅拷贝与深拷贝的区别

4.1.1 浅拷贝的定义

浅拷贝是指创建一个新对象，这个对象的属性和原对象的属性值相同，但当属性值为引用类型时，新对象与原对象共享这个属性值的内存地址。简单来说，浅拷贝只复制一层对象的属性，不复制对象里面的为引用对象的属性。

例如，当我们复制一个数组时：

const originalArray = [1, 2, [3, 4]];const shallowCopiedArray = [...originalArray];

shallowCopiedArray 是 originalArray 的浅拷贝。如果更改 shallowCopiedArray[2][0] 的值， originalArray[2][0] 也会受到影响，因为它们共享同一个数组对象。

4.1.2 深拷贝的定义

与浅拷贝相对，深拷贝则是将对象的所有层级进行完全复制，即使是嵌套对象和数组，新对象和原对象之间也不会有任何引用关系。

例如：

const originalArray = [1, 2, [3, 4]];const deepCopiedArray = JSON.parse(JSON.stringify(originalArray));

在这个例子中，如果修改 deepCopiedArray[2][0] ， originalArray[2][0] 不会被影响。

4.2 浅拷贝带来的问题及其解决方案

4.2.1 循环引用导致的问题

浅拷贝的局限性之一是不支持处理循环引用的对象。比如：

const circularRefObject = { prop: \"value\"};circularRefObject.self = circularRefObject;

尝试用浅拷贝复制这样的对象时会导致错误，因为浅拷贝没有机制来处理对象的自引用。

4.2.2 解决方案的探讨与实践

为了解决浅拷贝的局限性，我们可以使用深拷贝方法。但是，深拷贝的实现方法各有优劣，需要根据实际情况选择。

一种简单但有限制的方法是使用 JSON 方法：

const deepCopy = JSON.parse(JSON.stringify(objectToDeepCopy));

这个方法不能复制函数、undefined、循环引用的对象，以及不支持日期、正则表达式等特殊对象。对于需要这些特性的场合，我们可能需要使用递归函数来手动进行深拷贝。

4.2.3 手动实现深拷贝的递归函数

一个自定义的递归深拷贝函数可能如下：

function deepCopy(obj) { if (obj === null || typeof obj !== \'object\') { return obj; } if (obj instanceof Date) { return new Date(obj); } if (obj instanceof RegExp) { const flags = /\\w*$/.exec(obj.toString()); return new RegExp(obj.source, flags); } const copiedObj = Array.isArray(obj) ? [] : {}; for (const key in obj) { if (obj.hasOwnProperty(key)) { copiedObj[key] = deepCopy(obj[key]); } } return copiedObj;}

这个函数会检查每个属性的类型，并递归地进行拷贝。对于特殊对象，如日期和正则表达式，它还提供了特殊处理。

这种方法虽灵活，但效率可能不及内置的 structuredClone() ，如果浏览器支持。

4.3 深拷贝的实现方法

4.3.1 使用 structuredClone() 方法

随着Web标准的发展，现代浏览器开始支持 structuredClone() 函数，这是一个内置的深拷贝实现。

const deepCopy = structuredClone(originalObject);

它支持大部分数据类型，包括循环引用，但不能处理函数和一些特殊的对象类型。

4.3.2 结合库函数进行深拷贝

有时，为了更灵活地处理各种数据类型，我们会使用第三方库来实现深拷贝。比如 Lodash 库中的 _.cloneDeep() 方法：

const _ = require(\'lodash\');const deepCopy = _.cloneDeep(originalObject);

这些库通常会考虑到更多的边缘情况，并提供稳定的深拷贝功能。

4.4 小结

浅拷贝和深拷贝是处理对象和数组复制时需要考虑的重要概念。浅拷贝适用于简单复制且无嵌套引用对象的场景，而深拷贝适用于需要完整复制对象结构的场景。了解它们的原理和局限性，并掌握相应的解决方案，是编写健壮的JavaScript代码的关键。

5. Object.assign()在创建对象副本、初始化新对象、类的原型继承等方面的使用

在JavaScript中， Object.assign() 是一个强大的工具，用于合并对象、创建对象副本以及初始化新对象。此外，它在类的原型继承中也有其特定的应用场景。在这一章节中，我们将深入探讨这些应用，并分析其背后的工作机制以及使用时的最佳实践。

5.1 创建对象副本

5.1.1 使用Object.assign()复制对象

Object.assign() 最直观的一个用途就是复制对象。它能够将一个或多个源对象的所有可枚举属性复制到目标对象中。这个方法的基本用法如下：

const source = { a: 1, b: 2 };const target = {};const result = Object.assign(target, source);

在上述代码中， source 对象的属性被复制到了 target 对象中。 result 变量实际上指向 target ，因此返回值是目标对象。这意味着 target 和 source 将共享相同的属性值。如果 source 对象中的属性值是基本类型值（如数字或字符串），复制操作是值的复制；如果是引用类型值（如对象或数组），则复制的是引用。

5.1.2 深拷贝对象副本的方法

需要注意的是， Object.assign() 只进行浅拷贝。如果需要深拷贝对象，我们需要采用其他方法。一种常见的深拷贝实现如下：

function deepClone(obj) { if (obj === null || typeof obj !== \'object\') { return obj; } const copy = Array.isArray(obj) ? [] : {}; for (const key in obj) { if (obj.hasOwnProperty(key)) { copy[key] = deepClone(obj[key]); } } return copy;}

上面的 deepClone 函数可以递归地复制对象中的所有属性，包括嵌套的对象。它通过检查每个属性值的类型，并在必要时进行递归调用，实现深度复制。

5.2 初始化新对象

5.2.1 Object.assign()与对象字面量结合使用

在初始化新对象时， Object.assign() 可以和对象字面量语法结合使用，从而快速地给新对象设置默认属性值：

const defaults = { a: 0, b: 1 };const newObject = Object.assign({}, defaults, { a: 2 });console.log(newObject); // { a: 2, b: 1 }

在这个例子中， defaults 对象定义了一些默认属性， Object.assign() 调用首先创建了一个空对象，然后复制 defaults 中的属性，最后覆盖 a 的值为 2 。这样，新对象 newObject 就具有了所需的初始结构和值。

5.2.2 面向对象编程中初始化方法的改进

在面向对象的编程模式中， Object.assign() 可以用来改进对象的初始化方法，为新创建的实例自动设置初始状态。例如，我们可以定义一个工厂函数，使用 Object.assign() 来创建具有默认值的对象实例：

function createPerson(name, age) { return Object.assign({}, { name: \'Unknown\', age: 0, greet: function() { console.log(`Hello, my name is ${this.name} and I am ${this.age} years old.`); } }, { name, age });}

上述函数 createPerson 接受 name 和 age 参数，然后通过 Object.assign() 创建一个新对象，并将 name 和 age 属性合并进去。 greet 方法也被初始化为对象的一部分。

5.3 类的原型继承

5.3.1 在类继承中应用Object.assign()

在基于类的继承中， Object.assign() 可以用来合并原型对象，实现多继承的效果。假设我们有两个类，它们各自拥有不同的方法，我们希望通过一个新类来同时继承这两个类的功能：

class BaseClass1 { methodA() { console.log(\'Method A of BaseClass1\'); }}class BaseClass2 { methodB() { console.log(\'Method B of BaseClass2\'); }}class ChildClass extends BaseClass1 { constructor() { super(); Object.assign(this, new BaseClass2()); }}const childInstance = new ChildClass();childInstance.methodA(); // Method A of BaseClass1childInstance.methodB(); // Method B of BaseClass2

在这个例子中， ChildClass 继承自 BaseClass1 ，然后我们使用 Object.assign() 将 BaseClass2 的方法合并到 ChildClass 的实例中。这样， childInstance 就能够访问来自两个基类的方法。

5.3.2 原型链继承与Object.assign()的结合

虽然 Object.assign() 在原型链继承中不如 class 关键字和 extends 直接，但它仍然可以用来在原型链被破坏或修改时，合并多个原型对象：

const proto1 = { methodA() { console.log(\'Method A from proto1\'); }};const proto2 = { methodB() { console.log(\'Method B from proto2\'); }};function ChildClass() {}// 使用Object.assign()合并proto1和proto2到ChildClass.prototypeObject.assign(ChildClass.prototype, proto1, proto2);const childInstance = new ChildClass();childInstance.methodA(); // Method A from proto1childInstance.methodB(); // Method B from proto2

在这个例子中，我们没有使用 class 和 extends ，而是直接操作原型对象，利用 Object.assign() 将两个原型对象的属性合并到了 ChildClass 的原型中。这样的方法提供了额外的灵活性，尤其是在原型链可能被修改的情况下。

通过本章节的探讨，我们了解了如何使用 Object.assign() 在创建对象副本、初始化新对象、以及实现类的原型继承时发挥其作用。接下来的章节将探讨如何通过 Object.assign() 扩展默认参数，并提供提升代码可读性和维护性的建议。

6. 使用Object.assign()扩展默认参数的示例

6.1 默认参数与Object.assign()的结合使用

6.1.1 定义默认参数对象

在JavaScript中，函数可以使用默认参数来提供在调用时未明确提供的参数值。Object.assign()函数可以用来合并一个或多个对象的可枚举自有属性到目标对象中，这意味着它也可以用于扩展默认参数对象。

默认参数对象通常定义为函数作用域内的一个常量对象。这是因为默认参数应该在函数调用时保持不变，而const关键字可以帮助我们确保这一点。

function exampleFunction(a = 1, b = 2) { // 如果函数调用时没有提供参数a和b， // 则它们将分别默认为1和2。 return a + b;}// 使用Object.assign()来扩展默认参数const defaultParams = { a: 1, b: 2 };function exampleFunctionWithDefaults(...args) { // 将默认参数对象扩展到函数参数中 const { a, b } = Object.assign({}, defaultParams, ...args); return a + b;}exampleFunctionWithDefaults(); // 输出 3exampleFunctionWithDefaults({ a: 3 }); // 输出 5

在这个例子中，我们首先定义了一个 defaultParams 对象，它包含了默认参数。然后，在函数 exampleFunctionWithDefaults 中，我们使用扩展运算符 ... 将传入的参数对象解构为单独的参数，并使用 Object.assign() 将它们应用到默认参数对象上。如果调用者没有提供特定的参数，则默认值会被保留。

6.1.2 合并默认参数到实际参数中

在一些情况下，函数的参数可能来自多个来源，例如，一部分来自默认参数，一部分来自用户输入，还可能有一部分来自配置文件或者环境变量。Object.assign()可以方便地合并这些来自不同来源的参数对象。

const defaultParams = { a: 1, b: 2 };const configParams = { b: 10 };const envParams = { a: 100 };function exampleFunctionWithMultipleDefaults(a = defaultParams.a, b = defaultParams.b) { const mergedParams = Object.assign({}, defaultParams, { a, b }, configParams, envParams); return a + b; // 返回合并后的参数之和}exampleFunctionWithMultipleDefaults(); // 输出 101

在 exampleFunctionWithMultipleDefaults 函数中，我们定义了几个参数来源，并通过 Object.assign() 将它们合并到一个新对象中。 Object.assign() 从左到右依次将对象的属性复制到目标对象中，如果有重复的属性，后面的对象将覆盖前面的对象中的属性值。

6.2 实际编程中的应用案例

6.2.1 函数参数的默认值处理

在开发过程中，我们经常会遇到需要为函数参数设置默认值的情况。Object.assign()提供了一种简洁的方式来实现这一点。

function createPerson({name = \'Guest\', age = 21} = {}) { return { name, age };}let person1 = createPerson(); // 使用默认参数console.log(person1); // { name: \'Guest\', age: 21 }let person2 = createPerson({ name: \'John\', age: 30 }); // 传入覆盖默认参数的对象console.log(person2); // { name: \'John\', age: 30 }

在这个例子中， createPerson 函数接受一个参数对象，如果调用时不传入任何参数，那么这个参数对象将被赋予默认值。

6.2.2 避免参数重复赋值的技巧

在函数调用时，如果我们直接传入一个对象作为参数，并且这个对象中有某些属性未被用到，那么这些属性可能会被无意中覆盖默认参数值。为了避免这种情况，我们可以使用对象展开运算符 ... 来避免对默认参数对象的直接修改。

function test({ a = 1, b = 2 } = {}) { // 如果不使用对象展开运算符，直接传入参数对象可能会覆盖默认值 // 不推荐 // let result = test({ a: 3 }); // 使用对象展开运算符来避免覆盖默认值 let result = test({ ...{ a: 3 } }); return a + b;}console.log(test()); // 输出 3

使用对象展开运算符 ... 可以确保即使传入了额外的属性也不会影响函数的默认参数值。这样的实践可以保证代码的健壮性，避免因为无意中的参数覆盖而产生的错误。

在上述示例中，我们演示了如何利用 Object.assign() 和对象展开运算符来优雅地处理函数的默认参数。通过这种方式，我们不仅能够清晰地定义默认参数，还能在实际调用函数时灵活地覆盖这些默认值，从而增强了代码的可读性和维护性。

7. 提升代码可读性和维护性的建议

7.1 Object.assign()的最佳实践

7.1.1 清晰的代码风格指导

在使用 Object.assign() 时，遵循清晰和一致的代码风格可以显著提升代码的可读性。下面是一些建议：

明确属性合并顺序 ：当合并多个对象时，考虑合并的顺序，以避免不确定的行为。例如，如果你希望某个属性总是覆盖其他对象中的同名属性，应该将它放在合并列表的最后。
避免使用空对象 ：合并空对象 Object.assign({}, obj) 是常见的模式，但是当 obj 为 null 或 undefined 时会产生错误。应避免使用这种方式，或者使用可选链 Object.assign({}, obj?.a?.b) 来确保安全。
使用命名变量代替字面量 ：当你需要合并多个对象时，使用命名变量而非字面量来表达你的意图，这样其他开发者能够更清楚地理解你的代码。
文档注释 ：在使用 Object.assign() 的函数或方法中添加清晰的文档注释，解释合并的逻辑和合并对象的用途。

7.1.2 避免滥用Object.assign()的建议

虽然 Object.assign() 很强大，但它也有可能被滥用。以下是一些避免滥用 Object.assign() 的技巧：

只在必要时合并对象 ：如果你的目的是初始化对象或修改单一对象的属性，考虑使用对象字面量或 Object.fromEntries() 。
不用于不可变数据 ： Object.assign() 执行的是浅拷贝。如果你想保持对象的不可变性，应使用深拷贝方法。
考虑其他替代方法 ：当 Object.assign() 不能满足需求时，比如需要处理循环引用或嵌套对象，可以考虑使用其他库函数如 _.merge() 或 structuredClone() 。

7.2 可维护性与可扩展性的代码编写

7.2.1 设计可复用的函数和模块

创建可复用的代码是提高代码可维护性和可扩展性的关键。以下是如何做到这一点的建议：

编写通用函数 ：编写不特定于某个用例的通用函数，使得函数能够在不同的上下文中复用。
使用模块化设计 ：将代码拆分成独立的模块，每个模块负责一小部分功能。这样不仅使代码更加清晰，也便于在需要时重用和测试模块。
利用参数和配置 ：使用参数或配置对象来扩展函数的功能，允许在不修改函数内部代码的情况下，通过参数来改变行为。

7.2.2 代码重构与性能优化的平衡

在追求代码可维护性和可读性的同时，不要忘了考虑性能。在重构和优化时，考虑以下几点：

性能基准测试 ：在做出任何优化决策之前，先进行性能测试以确定瓶颈所在。
避免过度优化 ：在代码初期阶段，应优先考虑清晰性和可维护性。在实际发现性能问题之后，再考虑性能优化。
使用现代JavaScript特性 ：现代JavaScript提供了许多有助于提升性能和可读性的特性，例如箭头函数、模块、异步/等待等。合理使用这些特性可以同时提升代码的性能和可读性。

通过遵循上述建议，你可以编写出既具有可读性和可维护性，又具备高可用性的JavaScript代码。在使用 Object.assign() 时，务必保持谨慎，确保它是在当前上下文中最合适的选择。