JS合并数组生成新数组:concat与展开运算符对比

作者:青柠时间:2026-11-18 16:55:21浏览:97

深入对比JavaScript中合并数组生成新数组的两种主流方式:Array.prototype.concat与ES6展开运算符(...)。从语法使用、执行数据流、浅拷贝内存机制、核心行为差异到选型指南,提供完整代码示例与高清图解。

JavaScript 进阶教程 阅读时长约 8 分钟 纯函数式操作与内存解析
JS合并数组生成新数组:concat与展开运算符对比
图 0:JavaScript 合并数组生成新数组的两种核心途径概览

在 JavaScript 开发中,合并多个数组并生成一个包含全部项的新数组是一项极为高频的任务。现代 JavaScript 提供了两种最主要的语法手段:经典的 Array.prototype.concat() 原型方法与 ES6 引入的展开运算符(Spread Operator,即 [...arr1, ...arr2])。两者在常规业务场景下都能达成“不修改原数组、返回全新数组”的纯函数式目标,但在语法灵活性、对非数组实参的处理机制、对稀疏数组空槽(holes)的解析,以及对 Symbol.isConcatSpreadable 特性的响应上,存在关键的技术分歧。理解这些底层机制,有助于在代码编写中做出最稳妥的技术选型。

一、基本语法与操作数据流

在讨论差异之前,首先来看两种方案的标准调用方式与执行过程。两者的共同前提是保持输入数组的不可变性(Immutability),在内存中开辟全新连续区域存储合并后的项。

1. Array.prototype.concat()

concat() 是定义在 Array.prototype 上的内置方法。调用者作为基础数组,接收一个或多个参数,参数既可以是数组,也可以是单个数据项,最终返回合并后的新数组实例。

// 基础数组合并
const listA = ['apple', 'banana'];
const listB = ['cherry', 'date'];

const resultConcat = listA.concat(listB);

console.log(resultConcat); // 输出: ['apple', 'banana', 'cherry', 'date']
console.log(listA);        // 原数组不变: ['apple', 'banana']

2. 展开运算符(Spread Operator)

展开运算符使用三个点 ...,在数组字面量 [...] 内部将可迭代对象(Iterable)的项依次解构成离散的值并放入新容器中。

// 使用展开运算符合并
const listA = ['apple', 'banana'];
const listB = ['cherry', 'date'];

const resultSpread = [...listA, ...listB];

console.log(resultSpread); // 输出: ['apple', 'banana', 'cherry', 'date']
console.log(listA);        // 原数组不变: ['apple', 'banana']
JS合并数组生成新数组:concat与展开运算符对比
图 1:数组合并操作的四个阶段与数据流向机制

二、浅拷贝本质与对象引用共享

很多开发者在刚接触数组合并时,容易误以为生成新数组等同于“完整克隆”。然而,无论是 concat() 还是展开运算符,其底层执行的都是浅拷贝(Shallow Copy)。

这意味着:

  • 对于数字、字符串、布尔值等原始数据类型,引擎直接把数值复制到新数组对应的槽位中,修改原数组或新数组中的原始类型值互不影响。
  • 对于对象、嵌套数组等引用数据类型,引擎复制的仅仅是该对象在堆内存中的内存地址指针。新数组和原数组中对应位置的索引,实际指向同一个物理对象。
// 引用类型合并演示
const userA = { name: 'Alice', role: 'admin' };
const list1 = [userA];
const list2 = [{ name: 'Bob', role: 'editor' }];

// 使用展开运算符合并(换用 concat 结果完全相同)
const combined = [...list1, ...list2];

// 修改新数组中第 0 项对象的属性
combined[0].role = 'super_admin';

// 验证原数组
console.log(list1[0].role); // 输出: 'super_admin' (原对象被同步更改!)
JS合并数组生成新数组:concat与展开运算符对比
图 2:合并数组时的浅拷贝内存引用示意模型
防坑建议:若业务要求合并后的数组完全独立、深层修改不得污染原数据,必须在合并前或合并后执行深度克隆。在现代运行环境中,可优先选用原生的 structuredClone() 函数,例如:const deepMerged = structuredClone([...list1, ...list2]);。

三、concat 与展开运算符的核心差异

虽然常规数组合并两者表现高度一致,但在边界条件、语言规范与语法特性上,两者存在四个实质性区别。

1. 非数组参数与可迭代协议

concat() 会检查每个传入实参是否为数组。如果是数组,它会拆开该数组的第一层项;如果不是数组,它会把该实参作为一个独立元素直接追加。即使传入 null、undefined、数字或普通对象,concat() 也不会抛出异常。

相反,展开运算符依赖 JavaScript 的可迭代协议(Iterable Protocol)。在数组字面量中使用 ...x 时,x 必须部署了 [Symbol.iterator] 接口(例如 Array、Set、Map、字符串、arguments、NodeList)。如果对普通对象、数字、null 或 undefined 使用展开,运行时会直接抛出 TypeError。

// concat 对非数组的宽容处理
const base = [1, 2];
const res1 = base.concat(3, 4);      // 成功: [1, 2, 3, 4]
const res2 = base.concat(null);        // 成功: [1, 2, null]

// 展开运算符对非可迭代对象的严格限制
const res3 = [...base, 3, 4];         // 正常放入元素: [1, 2, 3, 4]
const res4 = [...base, ...3];        // 抛出 TypeError: 3 is not iterable!
const res5 = [...base, ...null];     // 抛出 TypeError: null is not iterable!

注意对字符串的处理差异:字符串本身是可迭代对象,展开运算符会将其拆解为单个字符数组,而 concat() 则将其视为一个完整的字符串项:

const arr = ['init'];

arr.concat('abc');   // 结果: ['init', 'abc']
[...arr, ...'abc'];  // 结果: ['init', 'a', 'b', 'c'] (按字符迭代展开)

2. 元素插入位置的灵活性

concat() 的语义是“追加拼接”,调用方固定在最前面,参数内容依次排列在末尾。若要在中间插入元素,concat() 必须搭配 slice() 切片多次才能完成。

展开运算符作为字面量语法,具有完全自由的位置编排能力。开发者可以在头部、尾部或任意指定位置穿插任意项或数组:

const middle = [3, 4];

// 在开头插入 1、2,中间展开 middle,末尾插入 5
const full = [1, 2, ...middle, 5]; // [1, 2, 3, 4, 5]

3. 对 Symbol.isConcatSpreadable 的支持

ES6 规范为 concat() 专门引入了一个知名符号属性 Symbol.isConcatSpreadable。通过配置该属性,开发者可以精确控制某对象是否在 concat() 调用时被拍平,甚至可以让一个类数组对象(Array-like Object)自动展开:

// 阻止普通数组被 concat 展开
const noSpread = [3, 4];
noSpread[Symbol.isConcatSpreadable] = false;
[1, 2].concat(noSpread); // 结果: [1, 2, [3, 4]]

// 展开运算符对 Symbol.isConcatSpreadable 完全忽略
[1, 2, ...noSpread];      // 仍然展开: [1, 2, 3, 4](只认 Symbol.iterator)

4. 稀疏数组(Sparse Arrays)与空槽处理

JavaScript 允许创建内部含有“空槽”(empty slot)的稀疏数组。concat() 与展开运算符在处理这些空槽时,内部遍历策略不同:

  • concat() 保留空槽特性。新数组中对应的槽位依然是 empty slot,不会生成真实拥有的属性键。
  • 展开运算符基于迭代协议工作,迭代器在读取空槽时返回 { value: undefined, done: false }。因此展开运算符会将空槽转化为实际具有索引属性、值为 undefined 的常规数组。
const sparse = [1, , 3]; // 长度为 3,索引 1 处为空槽

const byConcat = [].concat(sparse);
console.log(1 in byConcat);   // false (仍为空槽,索引 1 未被定义)

const bySpread = [...sparse];
console.log(1 in bySpread);   // true (索引 1 已被填充为 undefined)
JS合并数组生成新数组:concat与展开运算符对比
图 3:concat 与展开运算符在四大维度的核心行为矩阵

四、执行性能与内存开销分析

在日常大多数前端及服务端逻辑中,数组元素规模一般在数十到数千之间。在此规模下,现代 V8、JavaScriptCore 等引擎对两种方式都有深度内联优化,两者的耗时差距通常在微秒级别,几乎无法感知。

当数组规模达到十万到百万级超大数据集时,两者展现出不同的性能与资源特征:

  • 展开运算符 [...a, ...b]:作为字面量语法,引擎在编译期可直接分配对应规模的密集数组。但在某些极早期的转译器(如配置不当的旧 Babel)中,展开可能会被降级转译为 [].concat(...),需要关注打包目标配置。
  • concat():由于在 C++ 层面属于高度优化的成熟内部函数,处理极大规模密集数组时,由于无需经过迭代器协议的 next() 函数调用开销,通常具备更平稳的内存分配表现。
  • 避免使用 push.apply(a, b):过去曾有使用 a.push.apply(a, b) 合并数组的做法,但当 b 的长度超过 JS 引擎的最大调用栈限制(一般为 65536 或几十万项)时,会抛出 RangeError: Maximum call stack size exceeded。concat() 和展开运算符直接作用于堆数据,不会触发调用栈溢出。

五、选型指南与开发建议

综合语法便利性、类型安全性与业务需求,可以依据以下决策树进行选型:

JS合并数组生成新数组:concat与展开运算符对比
图 4:数组合并方案技术选型决策树

选型总结表

特性指标 Array.prototype.concat() 展开运算符 [...a, ...b]
语法类别 原型链内置方法(Method) 字面量解构语法(Syntax)
原数组可变性 不可变(返回全新数组) 不可变(返回全新数组)
拷贝深浅度 浅拷贝(共享对象引用) 浅拷贝(共享对象引用)
非数组参数 安全,自动作为单项追加 若非可迭代对象直接报 TypeError
插入位置灵活性 仅限追加末尾 开头、中间、末尾任意插值
稀疏数组空槽 保留 empty slot 转换为 undefined
现代推荐度 特定协议与高容错封装库场景 90% 以上业务开发的首选推荐
核心结论:在绝大部分现代业务开发中,展开运算符 [...a, ...b] 是首选方案,其语义清晰、语法紧凑,并且天然融入 ES6+ 解构规范。若封装底层工具库、面对不可控的非数组入参,或需要利用 Symbol.isConcatSpreadable 定制展开策略时,concat() 则是更具弹性的选择。无论选用哪种方式,都必须谨记浅拷贝的本质,在涉及嵌套对象时做好引用共享的防御处理。
作者最新文章
相关文章
更多