深入解析JavaScript中合并数组的两种核心方式:Array.prototype.concat()与ES6展开运算符(...)。对比两者在语法灵活性、非数组参数、稀疏数组、迭代协议及浅拷贝机制上的核心区别与选型建议。
JS数组合并:concat与展开运算符(...)的用法及区别
时间:2026-11-19
浏览:133
文章目录
在日常的 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'] (成功展开)
二、展开运算符 (...) 的用法与运作机制
展开运算符(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。
三、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]。
四、常见开发误区与避坑指南
误区一:以为合并操作实现了深度克隆
无论是 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]);
}
五、工程选型建议与技术决策
在日常业务开发与技术选型中,可以根据以下几条明确的判断路径进行选择:
- 日常业务开发首选展开运算符:在标准的现代 JavaScript / TypeScript 项目中,优先使用
[...arr1, ...arr2]。它的声明式语法更短、更符合直觉,并能在前后自由插入特定元素,代码可读性明显优于传统方法。 - 涉及非数组 Iterable 结构的直接合并:如果合并的数据来源包括
Set、Map.keys()或 DOMNodeList,展开运算符无需额外的Array.from()转换步骤,一次性即可完成。 - 需要保持稀疏数组或防御性接收任意参数:如果传入的参数可能不是集合(可能为单个标量对象),或者必须精确维持原稀疏数组的空位布局,使用
concat()是更严谨的选择。 - 需要借助 Symbol.isConcatSpreadable 实现自定义解包:在构建复杂数据结构库或类数组封装时,
concat()配合该 Symbol 是唯一受标准支持的解包定制协议。
实用工具推荐
绿化、压缩、噪点和虚拟水印,自由调节做旧程度。
选择画质和输出格式,预览压缩前后的大小。