稍候片刻,月出文自明。
const arr = [1, 2, 3];
// 展开:出现在表达式位置
[...arr, 4]; // [1, 2, 3, 4]
Math.max(...arr); // 3
// 剩余:出现在形参或解构目标的末尾
const [head, ...tail] = arr; // head 是 1,tail 是 [2, 3]
const { a, ...others } = { a: 1, b: 2 }; // others 是 { b: 2 }function* limit(n) {
let i = 0;
while (i < n) yield i++;
}
const it = limit(3);
[...it]; // [0, 1, 2]
[...it]; // []:迭代器已被消费完,不会从头开始
class Range {
constructor(n) { this.n = n; }
*[Symbol.iterator]() {
for (let i = 0; i < this.n; i++) yield i;
}
}
[...new Range(3)]; // [0, 1, 2]const arrayLike = { 0: 'a', 1: 'b', length: 2 };
Array.from(arrayLike); // ['a', 'b']:按 length 读取
[...arrayLike]; // TypeError: arrayLike is not iterableconst sparse = [1, , 3]; // 中间是空位
[...sparse]; // [1, undefined, 3]
sparse.slice(); // [1, empty, 3]:空位仍是空位const nums = [3, 5, 7];
Math.max(...nums); // 7
Math.max.apply(null, nums); // 7:ES5 的等价写法
Math.min(...[]); // Infinity:展开后是「没有实参」
function log(...args) {
console.log(...args); // 先用 rest 收,再 spread 转发
}const key = Symbol('k');
const src = { a: 1, [key]: 2 };
Object.defineProperty(src, 'hidden', { value: 3, enumerable: false });
const copy = { ...src };
Reflect.ownKeys(copy); // ['a', Symbol(k)]:symbol 键在,不可枚举的 hidden 不在const src = { x: 1 };
const target = { set x(v) { this.got = v; } };
Object.assign(target, src); // 走 [[Set]]:setter 被触发,target.got 是 1
const copy = { ...src }; // 定义属性:与 setter 无关,copy 是 { x: 1 }const state = { list: [], meta: { page: 1 } };
const next = { ...state, meta: { ...state.meta, page: 2 } };
next.list.push(1);
state.list; // [1]:list 仍是同一个数组,被就地改了
state.meta.page; // 1:meta 已被换成新对象,原对象没动function sum(...nums) { return nums.reduce((a, b) => a + b, 0); }
sum(1, 2, 3); // 6:nums 是 [1, 2, 3]
function split(first, ...rest) { return [first, rest]; }
split(1, 2, 3); // [1, [2, 3]]const user = { id: 7, name: 'Ada', password: 'x', token: 'y' };
const { password, token, ...safe } = user;
safe; // { id: 7, name: 'Ada' }:新对象,浅拷贝const nums = [3, 1, 2];
nums.sort((a, b) => a - b); // 原地修改:nums 变成 [1, 2, 3]
[...nums].sort(); // 先复制再排,原数组不动
nums.toSorted(); // ES2023:返回副本,同样不修改原数组
JavaScript 里 ... 是唯一一个由位置决定语义的语法符号:写在值的位置上,它把容器摊开(展开 / spread);写在形参列表或解构目标的末尾,它把剩下的东西收起来(剩余 / rest)。两者共用同一个符号,规则却完全不同,这也是它最容易被记混的地方。这篇文章按「判据 → 数组与可迭代对象 → 函数实参 → 对象 → 浅拷贝边界 → rest → 常见坑 → 规范与转译」的顺序,把这条线上能直接运行验证的结论整理一遍。
适合读者:已经会写 [...arr]、{...obj},但说不清「为什么展开一个类数组对象会报错」「symbol 键到底有没有被复制」「这次合并有没有保留原型」的人。文中每个结论都尽量标出可验证的写法,而不是口诀。
一、判据:位置决定语义
判断 ... 在做哪件事,只看它站在语法树的哪一侧,一句话就够:左边是形参或解构目标,就是收集;右边是表达式,就是展开。
三条硬性语法约束,写错就是 SyntaxError,不会在运行时才暴露:rest 必须放在最后;rest 元素不能带默认值(function f(...args = []) 与 const [a, ...rest = []] = arr 都不合法);展开每次都新建容器,不与原来的数组或对象共享引用。
二、展开数组:走的是迭代协议,不看 length
[...x] 只有一个条件:x 实现了 Symbol.iterator。它按迭代协议逐项取值,而不是读 length 和下标。由此得到几个很实用也常被忽略的结果:
类数组对象不等于可迭代对象,这是展开与 Array.from 最实质的差别:一个只有 length 和数字键的对象没有 Symbol.iterator,展开会抛 TypeError;Array.from 则先看迭代协议,没有就按 length 逐项读取,所以两种输入都能吃下。
还有一个只在细节题里出现的区别:稀疏数组的空位。迭代协议遇到空位会产出 undefined,所以展开会把空位变成实值;而 slice、concat 这类按索引复制的方法会保留空位。
三、展开做函数实参:两个边界
f(...args) 等价于把数组逐项当成实参传进去。ES5 时代只能写 f.apply(null, args),现在构造调用也能用,例如 new Date(...[2020, 0, 1])。最常见的用法是与 rest 组合,一个收一个转:
两条边界值得记住:
四、对象展开:复制的是自有、可枚举属性
{ ...obj } 的规则一句话说完:复制 obj 的自有、可枚举属性,包括 symbol 键。规范的 CopyDataProperties 用的是 OwnPropertyKeys,字符串键和 symbol 键都在其中——很多文章说「只复制字符串键」,那是把 Babel 某些宽松模式的产物当成了语言规则。
连带四条推论:
五、浅拷贝的边界与深拷贝的替代
展开只复制第一层。[...arr]、Array.from(arr)、arr.slice()、{...obj}、Object.assign({}, obj) 全部是浅拷贝:嵌套的对象、数组、Map 仍是共享引用。写不可变更新时,需要变的层级必须自己重建:
要真正的深拷贝,可选的两条路各有缺口:
结论:数据是纯 JSON 且层级浅时 JSON 三角够用,其余场合用 structuredClone,或者显式重建需要的结构。把 {...obj} 当深拷贝使用,是线上最难查的一类共享状态 bug。
六、剩余参数与解构里的 rest
function f(...args) 里的 args 是真正的数组,可以直接 map、reduce、length;而 arguments 是类数组对象,还有非严格模式下与形参双向映射的历史包袱。四条常被问到的差别:
解构里的 rest 让「剔除字段」写得很干净,这是它比 delete 更好的地方(不修改原对象):
两个注意点:safe 里能出现什么,完全由第四节的对象展开规则决定——原型上的方法和不可枚举字段本来就没被复制,所以「剔除」它们也无从谈起;对象 rest 同样会把 symbol 键带进 safe。
七、常见坑清单
八、规范、兼容与转译
数组展开属于 ES2015,随该版本在 2015—2016 年间被主流引擎实现;对象展开与对象 rest 属于 ES2018,落地晚得多:Chrome 60、Firefox 55、Safari 11.1、Node 8.3,Chromium 内核的 Edge 79;旧版 Edge 与 IE 完全不支持。这也是「对象展开为什么不能无条件用」的由来。
转译产物决定了运行时的细节,值得知道两条:
九、使用建议与自检