JS数组合并:concat与展开运算符(...)的用法及区别

作者:青柠

时间:2026-11-19

浏览:133

深入解析JavaScript中合并数组的两种核心方式:Array.prototype.concat()与ES6展开运算符(...)。对比两者在语法灵活性、非数组参数、稀疏数组、迭代协议及浅拷贝机制上的核心区别与选型建议。

文章目录
JS数组合并:concat与展开运算符(...)的用法及区别

在日常的 JavaScript 开发中,将两个或多个数组组合成一个新数组是最高频的数据处理操作之一。现代 JavaScript 为开发者提供了两种主要的解决路径:一种是诞生于 ECMAScript 3 的传统方法 Array.prototype.concat(),另一种是 ES6(ECMAScript 2015)引入的展开运算符语法 [...arr1, ...arr2]。它们都能在不改变原数组的前提下返回一个合并后的新数组,但在语法灵活性、非数组参数的处理机制、稀疏数组的处理规则以及对迭代协议的依赖上存在关键差异。本文将直接拆解这两种方式的具体用法,并通过对比和原理解析,明确它们各自的适用场景与边界。

一、Array.prototype.concat() 的用法与运作机制

concat() 是定义在 Array.prototype 上的原生实例方法。它的设计初衷是在保留所有调用方和参数数组不变的前提下,返回一个拼接所有元素的新数组。

1. 基本语法与多数组拼接

concat() 可以接收零个、一个或多个参数。参数不仅可以是数组,也可以是常规的非数组元素(如数字、字符串或普通对象):

// 基础合并两个数组
const letters = ['a', 'b'];
const numbers = [1, 2];
const combined = letters.concat(numbers);
// 结果: ['a', 'b', 1, 2]
// 原数组保持不变: letters 仍为 ['a', 'b']

// 一次性合并多个数组与独立元素
const moreNumbers = [3, 4];
const all = letters.concat(numbers, moreNumbers, 'extra', 99);
// 结果: ['a', 'b', 1, 2, 3, 4, 'extra', 99]

2. 单层扁平化特性与 Symbol.isConcatSpreadable

默认情况下,concat() 在遇到数组参数时,只会将其“解包”一层,不会递归展平嵌套数组。如果参数是一个多维数组,深层嵌套结构会被完整保留:

const nested = [1, [2, 3]];
const merged = nested.concat([4, [5, 6]]);
// 结果: [1, [2, 3], 4, [5, 6]]

此外,ES6 赋予了开发者定制对象在 concat 中是否被展开的能力,即通过内置的 Symbol.isConcatSpreadable 属性。例如,类数组对象默认不会被展开,但显式将其设为 true 后,concat() 会像处理标准数组一样把它的属性逐一加入新数组:

const arrayLike = { 0: 'hello', 1: 'world', length: 2 };
const res1 = [].concat(arrayLike);
// 结果: [{ 0: 'hello', 1: 'world', length: 2 }] (未展开)

arrayLike[Symbol.isConcatSpreadable] = true;
const res2 = [].concat(arrayLike);
// 结果: ['hello', 'world'] (成功展开)
JS数组合并:concat与展开运算符(...)的用法及区别
图 1:Array.prototype.concat() 内部参数处理流程与展开判定逻辑

二、展开运算符 (...) 的用法与运作机制

展开运算符(Spread Operator)是 ES6 引入的语言级操作符。当它在数组字面量 [...] 中使用时,其底层依赖于 JavaScript 的迭代协议(Iterable Protocol),通过调用对象的 Symbol.iterator 方法依次取出元素并填充进新数组。

1. 现代化字面量语法与位置自由插入

相比于方法调用的链式风格,展开运算符允许在数组字面量的任意位置插入元素,提供了更高的排版与组合灵活性:

const head = ['header', 'nav'];
const foot = ['footer', 'copyright'];

// 在头部、中间、尾部自由组合
const pageLayout = ['meta', ...head, 'main-content', ...foot, 'analytics'];
// 结果: ['meta', 'header', 'nav', 'main-content', 'footer', 'copyright', 'analytics']

2. 支持任意可迭代对象(Iterable)

因为展开运算符基于迭代协议工作,所以它天生支持将 Set、Map、字符串、函数的 arguments 对象以及 DOM 的 NodeList 等任意可迭代结构直接拼接到数组中:

const uniqueTags = new Set(['javascript', 'web', 'frontend']);
const defaultTags = ['tech'];

// 直接将 Set 展开并与普通数组合并
const allTags = [...defaultTags, ...uniqueTags];
// 结果: ['tech', 'javascript', 'web', 'frontend']

// 展开字符串为单个字符
const chars = ['start', ...'abc', 'end'];
// 结果: ['start', 'a', 'b', 'c', 'end']
注意事项:展开运算符在数组字面量中要求被展开项必须实现了 [Symbol.iterator]。如果试图对一个不可迭代的对象(如普通对象 { id: 1 }、null 或数字)使用展开运算符,JavaScript 引擎会立即抛出 TypeError: object is not iterable。
JS数组合并:concat与展开运算符(...)的用法及区别
图 2:展开运算符在执行合并时生成独立新数组,但对象属性仍共享堆内存引用

三、concat 与展开运算符的核心区别与对比

虽然两者的最终目的都是完成数组拼接,但由于设计年代和底层机制的不同,在实际编码中存在多维度的关键差异。

1. 针对非数组参数的处理机制

这是两者最显著的行为差异之一:

  • concat 的宽容性:可以传入任何数据类型(数字、对象、布尔值)。如果是基础数据类型,它会原样作为单项追加到结果中;如果传入 null 或 undefined,也会直接作为独立元素存入。
  • 展开运算符的严格性:在 [...] 内部,被展开的变量必须具备 [Symbol.iterator] 实现。如果传入数字、布尔值或普通对象,直接触发语法运行期报错 TypeError。
// 1. concat 的处理:安全包裹非数组对象
const c1 = [1, 2].concat(3);               // [1, 2, 3]
const c2 = [1, 2].concat({ name: 'Bob' }); // [1, 2, { name: 'Bob' }]

// 2. 展开运算符的处理
const s1 = [1, 2, ...[3]];                 // [1, 2, 3] (必须显式包装为数组或集合)
// const s2 = [1, 2, ...3];                // 抛出异常: TypeError: 3 is not iterable
// const s3 = [1, 2, ...{ name: 'Bob' }];  // 抛出异常: TypeError: object is not iterable

2. 稀疏数组(Sparse Array)空位保留情况

稀疏数组是指内部包含未定义空位(hole)的数组。两个工具对空位的处理哲学截然不同:

  • concat 保留空位:新生成的数组依然保留稀疏特性,空位不会被填充为实际值。
  • 展开运算符转换为 undefined:展开运算符基于迭代协议,数组迭代器在遍历空位时会产出 undefined,因此新数组变成了完全密集的数组。
const sparse = [1, , 3]; // 索引 1 处是空位 hole

const fromConcat = [].concat(sparse);
console.log(fromConcat);      // [1, 空, 3]
console.log(1 in fromConcat); // false (空位依然不存在对应属性索引)

const fromSpread = [...sparse];
console.log(fromSpread);      // [1, undefined, 3]
console.log(1 in fromSpread); // true (变成了包含 undefined 的实体元素)

3. 是否支持 Symbol.isConcatSpreadable

concat() 尊重 Symbol.isConcatSpreadable 标识。如果希望某个自定义类或类数组像数组一样被展开,或者强制某个数组在拼接时不要展开,可以设置该属性。然而,展开运算符完全忽略此标识,它唯一遵循的是 [Symbol.iterator]。

JS数组合并:concat与展开运算符(...)的用法及区别
图 3:Array.prototype.concat() 与展开运算符的核心差异矩阵

四、常见开发误区与避坑指南

误区一:以为合并操作实现了深度克隆

无论是 concat() 还是展开运算符 [...],返回的新数组都仅仅是浅拷贝(Shallow Copy)。对于数字、布尔值等基本类型,新数组拥有完全独立的副本;但对于数组内部嵌套的对象、数组或函数,新数组和原数组中存放的是同一个堆内存引用地址。修改合并数组中子对象的属性,原数组中的对应对象同样会被改变:

const list1 = [{ id: 1, title: 'Item 1' }];
const list2 = [{ id: 2, title: 'Item 2' }];

const merged = [...list1, ...list2];
// 尝试修改合并后数组里的第一个对象
merged[0].title = 'Updated Title';

console.log(list1[0].title); 
// 输出: 'Updated Title' —— 原数组 list1 受到污染!

如果业务场景要求完全隔离对象引用的修改,需要在合并前或合并后执行深拷贝(如 structuredClone() 或深拷贝库函数)。

误区二:误用 push(...bigArray) 导致调用栈溢出

有时开发者为了“原地修改”原数组,会写出 arr1.push(...arr2)。这种写法在 arr2 元素较少时非常简洁,但如果 arr2 是一个包含数万甚至数十万元素的大数组,展开运算符会将其转化为 push() 方法的实际入参列表,瞬间超出 JavaScript 引擎的单次函数调用参数限制,触发 RangeError: Maximum call stack size exceeded:

const largeArray = new Array(150000).fill('data');
const target = [1, 2];

// 危险操作: 容易引起调用栈溢出错误
// target.push(...largeArray); // 抛出: RangeError: Maximum call stack size exceeded

// 安全替代方案 1: 使用 concat 创建新数组
const safeMerged = target.concat(largeArray);

// 安全替代方案 2: 若必须原地修改,采用分批循环或原生循环追加
for (let i = 0; i < largeArray.length; i++) {
  target.push(largeArray[i]);
}

五、工程选型建议与技术决策

在日常业务开发与技术选型中,可以根据以下几条明确的判断路径进行选择:

  1. 日常业务开发首选展开运算符:在标准的现代 JavaScript / TypeScript 项目中,优先使用 [...arr1, ...arr2]。它的声明式语法更短、更符合直觉,并能在前后自由插入特定元素,代码可读性明显优于传统方法。
  2. 涉及非数组 Iterable 结构的直接合并:如果合并的数据来源包括 Set、Map.keys() 或 DOM NodeList,展开运算符无需额外的 Array.from() 转换步骤,一次性即可完成。
  3. 需要保持稀疏数组或防御性接收任意参数:如果传入的参数可能不是集合(可能为单个标量对象),或者必须精确维持原稀疏数组的空位布局,使用 concat() 是更严谨的选择。
  4. 需要借助 Symbol.isConcatSpreadable 实现自定义解包:在构建复杂数据结构库或类数组封装时,concat() 配合该 Symbol 是唯一受标准支持的解包定制协议。
JS数组合并:concat与展开运算符(...)的用法及区别
图 4:JavaScript 数组合并常见场景选型决策路径

实用工具推荐

电子包浆

绿化、压缩、噪点和虚拟水印,自由调节做旧程度。

使用 ›
图片压缩

选择画质和输出格式,预览压缩前后的大小。

使用 ›
相关文章