JavaScript-07-ES6新特性
本篇讲什么
ES6(正式名称 ES2015)是 JavaScript 诞生以来最大的一次升级:一次性加入了
let/const、箭头函数、class、模板字符串、解构、默认参数、剩余与展开、for...of、迭代器、生成器、Promise、Symbol、Map/Set、Proxy/Reflect、模块语法等十几项特性——今天写的每一行现代 JS 都建立在这批语法之上。本篇按"常用程度"排序逐项讲解:语法怎么用、为什么这样设计、什么时候会踩坑,并给出可直接运行的示例(标注运行环境)。此后 ES 版本改为每年发布一次,本篇也会说明这套节奏(TC39 Stage 0–4)与后续版本(ES2016 → 今天)各自带来了什么。
读完后你应该能读懂任何一段现代 JS,并且知道"这个语法是哪个版本引入的、目标环境支不支持"。
注:版本归属与提案阶段会持续演进,一律以 TC39 与 MDN 官方最新文档为准。
一、是什么:ES6 的历史意义与每年的发布节奏
1.1 为什么 ES6 被称为"分水岭"
在 ES6 之前,JavaScript 只有 var、函数作用域、function 与原型链。写大项目要靠一堆库和约定去弥补语言缺失的能力(Promise 靠 jQuery Deferred、模块靠 RequireJS、类靠自己写继承、Map 靠对象硬凑)。ES6 把这些能力一次性补进语言标准,直接后果是:
- 框架与工具链全面改写(Vue/React 的现代写法、Webpack/Rollup 的模块识别都依赖它);
- "用 ES6 写、转译给老浏览器跑"成为标准工程流程(Babel / TypeScript 的编译目标);
class、模块、迭代器等概念让 JS 的写法向主流语言靠拢,学习成本下降。
1.2 从"大版本"到"每年一发"
ES6 拖了六年才发布(2009 年开始讨论,2015 年定稿),教训是批次太大导致长期不可用。于是 TC39(Ecma TC39,负责 ECMAScript 标准的委员会)决定:每年发布一版,版本号直接用年份,例如 ES2016、ES2017……俗称的 "ES7 / ES8" 就是指 ES2016 / ES2017,官方文档里更倾向用年份。
| 版本 | 俗称 | 代表性新增(只列常用项) | ||
|---|---|---|---|---|
| ES2015 | ES6 | let/const、箭头函数、class、模板字符串、解构、默认/剩余/展开、for...of、迭代器、生成器、Promise、Symbol、Map/Set/WeakMap/WeakSet、Proxy/Reflect、模块语法、Number.isNaN 等 | ||
| ES2016 | ES7 | 幂运算符 **、Array.prototype.includes | ||
| ES2017 | ES8 | async/await、Object.values/entries、String.prototype.padStart/padEnd、Object.getOwnPropertyDescriptors | ||
| ES2018 | ES9 | 对象展开/剩余、异步迭代 for await...of、Promise.prototype.finally、正则命名捕获组与 s(dotAll)标志 | ||
| ES2019 | ES10 | Array.prototype.flat/flatMap、Object.fromEntries、String.prototype.trimStart/trimEnd、可选 catch 绑定、Symbol.prototype.description | ||
| ES2020 | ES11 | 可选链 ?.、空值合并 ??、BigInt、Promise.allSettled、globalThis、动态 import()、import.meta、String.prototype.matchAll | ||
| ES2021 | ES12 | String.prototype.replaceAll、Promise.any、逻辑赋值 ` | =/&&=/??=、WeakRef、数字分隔符 1_000_000` | |
| ES2022 | ES13 | 顶层 await、class 字段与私有 # 字段、静态初始化块、Array.prototype.at、Object.hasOwn、Error 的 cause | ||
| ES2023 | ES14 | findLast/findLastIndex、不改原数组的 toSorted/toReversed/toSpliced/with、Hashbang 语法 | ||
| ES2024 | ES15 | Object.groupBy/Map.groupBy、Promise.withResolvers、正则 v 标志、可调整大小的 ArrayBuffer | ||
| ES2025 | ES16 | 迭代器辅助方法(Iterator.prototype.map/filter/take 等)、Set 集合运算(union/intersection/difference 等)、Promise.try、RegExp.escape |
上表只用于建立"时间感",不要背
版本归属会随提案进度变动,个别特性还可能被撤回或改名。需要精确信息时查两处:MDN 各 API 页面的「浏览器兼容性 / 规范」表格,以及 TC39 的提案仓库与语言规范。以官方最新文档为准。
1.3 TC39 提案流程:Stage 0 – Stage 4
一个新语法从想法到进标准要走五个阶段(数字越大越接近落地):
| 阶段 | 名称 | 含义 | 你要不要用 |
|---|---|---|---|
| Stage 0 | 设想(Strawperson) | 只是 TC39 成员提出的想法,还没成形 | 不要 |
| Stage 1 | 提案(Proposal) | 有负责人(champion),问题与大致解法明确,进入评审 | 不要 |
| Stage 2 | 草稿(Draft) | 有正式规范文本,委员会原则上接受这个方向 | 谨慎,语法可能变 |
| Stage 3 | 候选(Candidate) | 规范文本完成,等待实现反馈与测试(test262)验证 | 可用,但要有转译兜底 |
| Stage 4 | 完成(Finished) | 至少两个独立实现通过测试,纳入下一年度标准 | 可用(仍需看目标环境) |
工程上的判断标准
"进 Stage 4 且目标运行环境支持"才是投产标准。 Stage 3 的特性即使引擎已实现,也可能在上线前改语法或被移除;用转译器(Babel / TypeScript)也只能转译语法,无法凭空补出运行时不支持的能力(如
Proxy、WeakRef)。流程细节可能调整,请以 TC39 官方流程文档为准。
二、为什么这样设计:ES6 的四个设计主线
| 设计主线 | 具体体现 | 解决的问题 | 代价 |
|---|---|---|---|
| 消灭样板代码 | 解构、展开、简写、模板字符串、默认参数 | 早期取值要写 var a = obj.a,拼接字符串用 + | 语法密度变高,过度使用会降低可读性 |
| 让作用域可预测 | let/const、块级作用域、TDZ | var 的变量提升与循环陷阱 | 需要理解 TDZ,混用 var 更容易迷惑 |
| 从"值"走向"协议" | 迭代器协议、可迭代协议、生成器、Symbol | for 循环各写一套,for...in 语义混乱 | 抽象层次提高,初学时要先理解协议 |
| 把元编程写进语言 | Proxy/Reflect、well-known symbols | 想拦截对象操作只能靠约定或改写方法 | 性能与调试复杂度上升,拦截器是"隐形"的 |
一句话抓住本质
ES6 不是"加了几个语法糖",而是给 JavaScript 补上了三样东西:块级作用域(作用域模型)、迭代协议(统一的遍历抽象)、元编程能力(
Symbol与Proxy)。Promise、生成器、for...of全都建立在这三样之上。
三、核心内容
3.1 解构赋值(Destructuring)
解构是"按模式取值":左边写形状,右边写数据源。
// 运行环境:Node.js(本机实测 v24.18.0)或任意现代浏览器控制台
// ① 数组解构:按位置
const [first, second] = ['a', 'b'];
console.log(first, second); // a b
// ② 默认值:只在对应位置是 undefined 时生效
const [x = 1, y = 2] = [10, undefined];
console.log(x, y); // 10 2 —— null 不会触发默认值
// ③ 跳过元素 + 剩余元素
const [, , third, ...tail] = [1, 2, 3, 4, 5];
console.log(third, tail); // 3 [4, 5]
// ④ 对象解构:按属性名
const user = { name: 'Ada', age: 36 };
const { name, age } = user;
console.log(name, age); // Ada 36
// ⑤ 重命名:原名: 新名
const { name: userName, age: userAge = 0 } = user;
console.log(userName, userAge); // Ada 36
// ⑥ 嵌套解构 + 嵌套默认值(防止对 undefined 继续解构)
const resp = { data: { list: [{ id: 1 }] } };
const { data: { list: [firstItem] = [] } = {} } = resp;
console.log(firstItem); // { id: 1 }
const { data: { list: [zero] = [] } = {} } = {}; // 空对象也不会报错
console.log(zero); // undefined
// ⑦ 交换变量:不再需要临时变量
let p = 1, q = 2;
[p, q] = [q, p];
console.log(p, q); // 2 1
// ⑧ 函数参数解构:调用方传对象,函数内直接取字段
function render({ title, tags = [], meta: { author = '匿名' } = {} }) {
return `${title} by ${author} [${tags.join('/')}]`;
}
console.log(render({ title: 'ES6', tags: ['js'], meta: { author: 'Ada' } })); // ES6 by Ada [js]
console.log(render({ title: 'ES6' })); // ES6 by 匿名 []
// ⑨ 在循环里解构:Object.entries / Map 的经典用法
for (const [key, value] of Object.entries({ a: 1, b: 2 })) {
console.log(key, value); // a 1 / b 2
}
解构的返回值与"无声明赋值"陷阱
- 解构表达式本身返回右边那个值,所以
const o = { a: 1 }; const r = ({ a } = o);里r === o。- 以
{开头的语句会被当成块语句,必须加括号:({ a } = obj);。- 解构
null或undefined会抛TypeError;对"可能不存在"的层级要给默认值= {}。
3.2 展开与剩余运算符 ...
同一个 ...,在调用/字面量里是展开(spread),在赋值/参数位置是剩余(rest)。
// 运行环境:Node.js(实测 v24.18.0)或浏览器控制台
// ① 数组浅拷贝与合并
const a1 = [1, 2];
const copy = [...a1];
const merged = [...a1, ...[3, 4], 5];
console.log(copy, merged); // [1, 2] [1, 2, 3, 4, 5]
// ② 对象浅拷贝与合并(后者覆盖前者)
const base = { theme: 'dark', size: 12, deep: { k: 1 } };
const override = { ...base, size: 14 };
console.log(override); // { theme: 'dark', size: 14, deep: { k: 1 } }
override.deep.k = 99;
console.log(base.deep.k); // 99 —— 浅拷贝!嵌套对象仍是同一个引用
console.log(base.deep === override.deep); // true
// ③ 函数剩余参数:替代 arguments,且是真正的数组
function sum(...nums) { return nums.reduce((s, n) => s + n, 0); }
console.log(sum(1, 2, 3)); // 6
function log(level, ...messages) { return `${level}: ${messages.join(' ')}`; }
console.log(log('INFO', '启动', '完成')); // INFO: 启动 完成
// ④ 把可迭代对象转成数组
console.log([...'中文ab']); // [ '中', '文', 'a', 'b' ] —— 字符串可迭代
function argsToArray() { return [...arguments]; }
console.log(argsToArray(1, 2, 3)); // [1, 2, 3](arguments 可迭代)
console.log(new Set([1, 1, 2])); // Set 可直接展开: [...new Set([1,1,2])] → [1, 2]
// ⑤ 只有 length 的"伪数组"必须用 Array.from
const fakeArray = { 0: 'a', 1: 'b', length: 2 };
console.log(Array.from(fakeArray)); // [ 'a', 'b' ]
// console.log([...fakeArray]); // TypeError: fakeArray is not iterable(实测)
| 目标 | 写法 | 注意 |
|---|---|---|
| 数组浅拷贝 | [...arr] | 元素是对象时仍是共享引用 |
| 对象浅拷贝 | { ...obj } | 只复制自有可枚举属性;不复制原型、getter 会求值 |
| 合并配置 | { ...defaults, ...options } | 后面的覆盖前面的;嵌套层不会深合并 |
| 可变参数 | function f(...args) {} | 剩余参数必须是最后一个,且函数不能再用 arguments 风格混用 |
| 类数组转数组 | [...iterable] | 只对可迭代对象有效(字符串、arguments、NodeList、TypedArray) |
| 伪数组转数组 | Array.from(arrayLike) | 只有 length 和下标的对象只能用它 |
展开是浅拷贝,别拿它做深拷贝
{ ...obj }与[...arr]都只复制第一层。要真正深拷贝,可用structuredClone(obj)(现代运行时与浏览器已内置)或成熟的深拷贝库;JSON.parse(JSON.stringify(obj))会丢undefined、Date、Map等,不要作为通用方案。
3.3 模板字符串(Template Literal)
// 运行环境:Node.js(实测 v24.18.0)或浏览器控制台
const user = { name: 'Ada', score: 92 };
// ① 插值:任意表达式都能放,不必再拼 +
console.log(`你好,${user.name}!成绩:${user.score},等级:${user.score >= 90 ? 'A' : 'B'}`);
// 你好,Ada!成绩:92,等级:A
// ② 多行字符串:换行就是换行,不需要 \n 拼接
const html = `
<div class="card">
<h3>${user.name}</h3>
</div>`.trim();
console.log(html.split('\n').length); // 3
// ③ 嵌套与函数调用
const rows = [{ n: '键盘', p: 399 }, { n: '鼠标', p: 99 }];
const table = rows.map((r) => `<tr><td>${r.n}${r.p}</td></tr>`).join('');
console.log(table);
// ④ 标签模板(Tagged Template):把模板交给函数处理
// 第一个参数是"字符串片段数组"(带 raw 属性保存未转义原文),其余参数是各插值
function highlight(strings, ...values) {
return strings.reduce((out, str, i) => out + str + (values[i] !== undefined ? `【${values[i]}】` : ''), '');
}
console.log(highlight`价格是 ${399} 元,折扣 ${0.8}`);
// 价格是 【399】 元,折扣 【0.8】
function raw(strings) { return strings.raw[0]; } // raw 保留 \n 两个字符
console.log(raw`a\nb`); // a\nb(不是换行)
console.log(`a\nb`); // a 换行 b
// ⑤ 实战:HTML 转义(标签模板最经典的用途之一)
const escapeHtml = (s) => String(s).replace(/[&<>"']/g, (c) => ({
'&': '&', '<': '<', '>': '>', '"': '"', "'": ''',
}[c]));
function safeHtml(strings, ...values) {
return strings.reduce((out, str, i) => out + str + (values[i] !== undefined ? escapeHtml(values[i]) : ''), '');
}
console.log(safeHtml`<p>${'<script>alert(1)</script>'}</p>`);
// <p><script>alert(1)</script></p>
3.4 简写语法(Shorthand)
// 运行环境:Node.js(实测 v24.18.0)或浏览器控制台
const name = 'Ada', age = 36;
const key = 'theme', index = 2;
const obj = {
name, // ① 属性简写:等价于 name: name
age,
greet() { return `我是 ${this.name}`; }, // ② 方法简写:等价于 greet: function () {}
async load() { return 1; }, // 异步方法同样可简写
*gen() { yield 1; }, // 生成器方法简写
[key]: 'dark', // ③ 计算属性名:用变量的值做键
[`item-${index}`]: true, // 表达式也可以
['get' + 'Name']() { return this.name; },
get upperName() { return this.name.toUpperCase(); }, // 访问器也可以定义在字面量里
};
console.log(obj.theme, obj['item-2'], obj.getName(), obj.upperName, obj.greet());
简写会让"函数名/属性名"与来源耦合
const { data } = resp; 与 { data } 简写虽短,但重命名时容易漏改;此外方法简写与箭头函数不同——方法简写有动态 this,解构出来单独调用会丢 this。this 的完整规则见 JavaScript-02-函数与作用域。
3.5 箭头函数:与普通函数的对比
箭头函数在 JavaScript-02-函数与作用域 中已详细展开(含 this 四条绑定规则),这里只保留结论式对比,便于速查。
对比项 普通函数 / 方法简写 箭头函数 () => {} this调用时决定(动态绑定) 取定义处的外层 this(词法绑定) arguments有 没有(用剩余参数代替) 能否 new 能 不能(没有 [[Construct]]) prototype 属性有 没有 能否作生成器 能(function*) 不能 提升 函数声明完整提升 表达式,不提升(const + TDZ) 返回对象字面量 正常 必须加括号:() => ({ a: 1 }) 适合场景 对象方法、构造函数、需要动态 this 回调、需要沿用外层 this、短小的纯函数
3.6 let / const 与块级作用域
let / const 的完整对比(含 TDZ、与 var 的提升差异、const 对象可变的说明)见 JavaScript-01-基础语法与类型。这里只需记住三条:
let / const 是块级作用域,{ }、for、if 都能形成作用域;
- 声明前访问进入暂时性死区(TDZ),抛
ReferenceError(这是好事,能提早暴露 bug);
const 锁的是绑定不是值:const obj = {} 之后 obj.a = 1 完全合法,但不能 obj = {}。
3.7 Symbol:唯一且不会被撞名的属性键
// 运行环境:Node.js(实测 v24.18.0)或浏览器控制台
// ① 每次调用都是全新的唯一值,描述只是调试用
const s1 = Symbol('id'), s2 = Symbol('id');
console.log(s1 === s2); // false
console.log(String(s1)); // Symbol(id)
console.log(s1.description); // 'id'(ES2019)
// ② 作为属性键:不会与任何字符串键冲突
const key = Symbol('secret');
const obj = { [key]: '内部数据', plain: 1 };
console.log(obj[key]); // 内部数据
console.log(Object.keys(obj)); // [ 'plain' ] —— Symbol 键不出现在这里
console.log(Object.getOwnPropertySymbols(obj).length); // 1(想看还是能看到)
console.log(JSON.stringify(obj)); // {"plain":1}
// ③ 全局注册表:跨模块共享同一个 Symbol(不是私有,只是不会撞名)
console.log(Symbol.for('app.token') === Symbol.for('app.token')); // true
console.log(Symbol.keyFor(Symbol.for('app.token'))); // 'app.token'
// ④ well-known symbols:语言内部约定的"钩子"
console.log([Symbol.iterator, Symbol.asyncIterator, Symbol.hasInstance,
Symbol.toPrimitive, Symbol.toStringTag].map(String).join(' '));
// Symbol(Symbol.iterator) Symbol(Symbol.asyncIterator) ...
class MyNum {
constructor(v) { this.v = v; }
[Symbol.toPrimitive](hint) { return hint === 'number' ? this.v : `MyNum(${this.v})`; }
get [Symbol.toStringTag]() { return 'MyNum'; }
}
const mn = new MyNum(7);
console.log(mn * 2); // 14(number 提示)
console.log(`${mn}`); // MyNum(7)
console.log(Object.prototype.toString.call(mn)); // [object MyNum]
well-known symbol 作用 Symbol.iterator定义默认迭代器,for...of / 展开 / 解构都靠它 Symbol.asyncIterator定义异步迭代器,供 for await...of 使用 Symbol.toPrimitive控制类型转换(hint 为 'number' / 'string' / 'default') Symbol.toStringTag定制 Object.prototype.toString 的输出 Symbol.hasInstance定制 instanceof 的行为 Symbol.isConcatSpreadable控制 concat 时是否展开 Symbol.match / replace / search / split让自定义对象能被字符串方法当作正则使用 Symbol.species指定派生对象的构造函数
Symbol 不是"私有属性"
Object.getOwnPropertySymbols()、Reflect.ownKeys() 都能拿到 Symbol 键,它不是访问控制手段。真正的私有要看 class 的 #field 语法,或者靠 WeakMap / 闭包封装。
3.8 迭代器与可迭代协议:for...of 的原理
JavaScript 用两个协议统一了"遍历":
- 可迭代协议(iterable):对象有
[Symbol.iterator]() 方法,调用后返回一个迭代器;
- 迭代器协议(iterator):对象有
next() 方法,每次返回 { value, done },done 为 true 表示结束。
for...of 的执行过程就是:取 [Symbol.iterator]() → 反复 next() → 直到 done。
// 运行环境:Node.js(实测 v24.18.0)或浏览器控制台
// ① 手写一个可迭代对象:生成 [from, to] 的整数序列
const range = {
from: 1,
to: 3,
[Symbol.iterator]() {
let current = this.from;
const last = this.to;
return {
next() {
return current <= last
? { value: current++, done: false }
: { value: undefined, done: true };
},
// 可选:提前退出(break/return/异常)时会被调用,用来释放资源
return() { console.log('迭代器被提前关闭'); return { value: undefined, done: true }; },
};
},
};
console.log([...range]); // [ 1, 2, 3 ]
console.log(Array.from(range)); // [ 1, 2, 3 ]
for (const n of range) { if (n === 2) break; console.log(n); } // 打印 1,然后"迭代器被提前关闭"
// ② 内置可迭代对象一览:都能直接 for...of 与展开
console.log([...'ab'], [...new Set([1, 1, 2])], [...new Map([['k', 1]])]);
console.log([...new Uint8Array([1, 2])]); // [1, 2]
// ③ 普通对象不是可迭代的
try {
for (const v of { a: 1 }) {}
} catch (e) {
console.log(e.constructor.name, e.message); // TypeError ... is not iterable(实测)
}
// 想遍历对象:Object.entries / Object.keys,或自己给它加 Symbol.iterator
console.log(Object.entries({ a: 1, b: 2 }));
遍历方式 遍历对象 能否 break 适合场景 for...of可迭代对象(数组、字符串、Map、Set、生成器) 能 首选,语义最清晰 for...in对象的可枚举字符串键(含原型链上的) 能 只用于调试对象键;遍历数组是常见事故 forEach数组(Map/Set 也有) 不能 简单累加/副作用;需要提前退出就别用 for 经典循环数组(按下标) 能 需要索引、需要倒序、性能敏感的紧循环
3.9 生成器函数 function* 与 yield
生成器是"能暂停的函数":执行到 yield 就交出值并挂起,下次 next() 从原地继续。它天生满足迭代器协议,所以可以直接 for...of。
// 运行环境:Node.js(实测 v24.18.0)或浏览器控制台
// ① 基本用法:next() 的返回值与"恢复时传入的值"
function* gen() {
const got = yield 1; // 暂停在 yield 1;恢复时参数成为整个 yield 表达式的值
yield got * 10;
return '结束值'; // return 的值出现在 done: true 的那一次
}
const it = gen();
console.log(it.next()); // { value: 1, done: false } —— 第一次 next 的参数会被丢弃
console.log(it.next(5)); // { value: 50, done: false }
console.log(it.next()); // { value: '结束值', done: true }
// ② 生成器对象既是迭代器也是可迭代对象
const g = gen();
console.log(typeof g[Symbol.iterator], g[Symbol.iterator]() === g); // function true
// ③ yield* 委托给另一个可迭代对象
function* chain() { yield* [1, 2]; yield* 'ab'; }
console.log([...chain()]); // [ 1, 2, 'a', 'b' ]
// ④ 实战:惰性无限序列(只有在取用时才计算)
function* naturals() { let n = 1; while (true) yield n++; }
function* take(iterable, count) { let i = 0; for (const v of iterable) { if (i++ >= count) return; yield v; } }
console.log([...take(naturals(), 5)]); // [1, 2, 3, 4, 5]
// ⑤ 实战:用生成器接管异步流程(async/await 之前的经典方案,理解 await 原理时很有用)
function* workflow() {
const a = yield Promise.resolve(1);
const b = yield Promise.resolve(a + 1);
return b;
}
function run(genFn) {
const it = genFn();
return (function step(arg) {
const { value, done } = it.next(arg);
return done ? Promise.resolve(value) : value.then(step);
})();
}
run(workflow).then((v) => console.log('结果:', v)); // 结果: 2
生成器与迭代器的关系
生成器函数返回的对象自动实现了两个协议,因此你不需要手写 next()。反过来,async 函数可以看作"生成器 + 自动驱动"的语法糖:yield 换成 await,把 Promise 的 then 链交给引擎处理。异步的完整机制见 JavaScript-04-异步编程。
3.10 Map / Set / WeakMap / WeakSet
// 运行环境:Node.js(实测 v24.18.0)或浏览器控制台
// ① Map:键可以是任意类型,按插入顺序迭代
const m = new Map([['a', 1], [2, 'two']]);
const objKey = { id: 1 };
const m2 = new Map([[objKey, '对象键']]);
console.log(m.get('a'), m.get(2), m2.get(objKey), m.size); // 1 two 对象键 2
console.log([...m.keys()], [...m]); // [ 'a', 2 ] [ [ 'a', 1 ], [ 2, 'two' ] ]
// 对比:普通对象的键会被强制转成字符串
const plain = {};
plain[{ id: 1 }] = 'v';
console.log(Object.keys(plain)); // [ '[object Object]' ] —— 两个对象键会互相覆盖
// ② Set:自动去重,判定用 SameValueZero(NaN 视为相同)
const s = new Set([1, 1, 2, NaN, NaN]);
console.log([...s], s.has(NaN), s.size); // [ 1, 2, NaN ] true 3
// ③ 与数组互转、与对象互转
console.log([...new Set([3, 1, 3])]); // [3, 1]
console.log(Object.fromEntries(m)); // { '2': 'two', a: 1 } —— 键会变字符串!
console.log(new Map(Object.entries({ a: 1 }))); // Map(1) { 'a' => 1 }
// ④ WeakMap:键必须是对象,弱引用,不可枚举
const wm = new WeakMap();
let node = {};
wm.set(node, 'DOM 元数据');
console.log(wm.get(node)); // DOM 元数据
console.log('size' in wm, wm.size); // false undefined —— 没有 size/keys/forEach
node = null; // 没有其他引用后,这个键值对可被垃圾回收
try { new WeakMap().set('str', 1); } catch (e) { console.log(e.message); } // Invalid value used as weak map key
// ⑤ WeakSet:只能装对象,不可迭代
const ws = new WeakSet();
const el = {};
ws.add(el);
console.log(ws.has(el)); // true
// console.log([...ws]); // TypeError: ws is not iterable(实测)
对比项 普通对象 {} MapSetWeakMap / WeakSet键的类型 只能是字符串或 Symbol 任意类型(含对象、函数、NaN) 元素即键 只能是对象(否则 TypeError) 迭代顺序 整数键升序在前,其余按插入顺序 严格插入顺序 插入顺序 不可迭代 取大小 Object.keys(o).length,size,size没有 size 查找复杂度 属性查找接近 ,但键被转成字符串 get 约 has 约 ,而 Array.includes 是 has 约 键是否阻止垃圾回收 是 是 是 否(弱引用) 可枚举/可序列化 JSON.stringify 直接支持需 Object.fromEntries 转换 需展开成数组 都不支持 典型用途 结构化的数据、配置 频繁增删的字典、对象做键 去重、集合运算 给对象挂"私有"数据、缓存、DOM 元数据
Weak 版本存在的唯一理由:不阻止垃圾回收
Map 持有键的强引用:只要 Map 活着,键对象就永远不会被回收——把 DOM 节点当键缓存,页面就会持续泄漏内存。WeakMap 的键是弱引用,对象被回收时对应的条目自动消失,因此引擎不需要(也不允许)提供 size、迭代和 clear:这些 API 会暴露"当前有多少条"这种依赖 GC 时机的不确定信息。
实践中的典型用法:给 DOM 节点挂状态、实现"每个对象一份"的私有数据、给对象做无泄漏缓存。
3.11 Proxy 与 Reflect:把拦截写进语言
Proxy 用拦截器(trap,也叫"陷阱")包住目标对象,任何对代理的操作都先经过你。
// 运行环境:Node.js(实测 v24.18.0)或浏览器控制台
// ① 校验:set 陷阱做数据校验
function createValidated(target, schema) {
return new Proxy(target, {
set(obj, prop, value) {
const rule = schema[prop];
if (rule && !rule(value)) throw new TypeError(`${String(prop)} 校验失败:${value}`);
return Reflect.set(obj, prop, value); // 用 Reflect 转发,别写 obj[prop] = value(会递归)
},
get(obj, prop, receiver) {
if (!(prop in obj)) console.warn(`读取了不存在的属性 ${String(prop)}`);
return Reflect.get(obj, prop, receiver);
},
});
}
const user = createValidated({ name: 'Ada' }, { name: (v) => typeof v === 'string' && v.length > 0 });
user.name = 'Bob';
console.log(user.name); // Bob
try { user.name = ''; } catch (e) { console.log(e.message); } // name 校验失败:
// ② 极简响应式:Vue 3 响应式的核心思路
function reactive(target, onChange) {
return new Proxy(target, {
get(obj, key, receiver) {
const value = Reflect.get(obj, key, receiver);
return typeof value === 'object' && value !== null ? reactive(value, onChange) : value; // 惰性递归
},
set(obj, key, value, receiver) {
const ok = Reflect.set(obj, key, value, receiver);
onChange(key, value); // 通知依赖方更新
return ok;
},
});
}
const state = reactive({ count: 0, nested: { title: 'hi' } }, (k, v) => console.log(`变化 -> ${String(k)} =`, v));
state.count++; // 变化 -> count = 1
state.nested.title = 'hello'; // 变化 -> title = hello
// ③ 拦截函数调用与构造
const add = new Proxy(function () {}, { apply: (t, thisArg, args) => args.reduce((a, b) => a + b, 0) });
console.log(add(1, 2, 3)); // 6
class Point { constructor(x, y) { this.x = x; this.y = y; } }
const PointProxy = new Proxy(Point, { construct: (T, args) => ({ ...new T(...args), created: true }) });
console.log(new PointProxy(1, 2)); // { x: 1, y: 2, created: true }
trap(拦截器) 拦截的操作 对应的 Reflect 方法 get读取属性 obj.x Reflect.getset写入属性 obj.x = v Reflect.sethas'x' in objReflect.hasdeletePropertydelete obj.xReflect.deletePropertyownKeysObject.keys、Reflect.ownKeysReflect.ownKeysgetOwnPropertyDescriptorObject.getOwnPropertyDescriptorReflect.getOwnPropertyDescriptordefinePropertyObject.definePropertyReflect.definePropertygetPrototypeOf / setPrototypeOf读取/设置原型 Reflect.getPrototypeOf / Reflect.setPrototypeOfisExtensible / preventExtensions可扩展性检查与冻结 同名方法 apply函数调用 fn() Reflect.applyconstructnew fn()Reflect.construct
Proxy 的四个必须知道的限制
1. 拦截器有"不变量"约束:例如目标对象被 preventExtensions 后,ownKeys 不能报告不存在的键;对不可配置、不可写属性,get 必须返回原值。违反会抛 TypeError。
2. 只能代理对象,原始值不行;被代理后的 this 指向要留意,所以转发时优先用 Reflect.xxx(obj, ...) 而不是 obj.xxx。
3. 代理的是"操作"而不是"值":const { a } = proxy 之后拿到的 a 不再受 get 之外的拦截影响;深层对象需要像示例那样在 get 里惰性包装。
4. 性能与调试成本:高频属性访问会成倍增加开销,栈里出现的是 trap 而不是原始代码。JSON.stringify(proxy)、console.log(proxy) 也可能触发陷阱。
Vue 2 与 Vue 3 的响应式对比
Vue 2 用 Object.defineProperty 递归改写每个属性:无法侦测对象新增/删除属性(所以有 Vue.set),也无法直接支持 Map/Set,数组要重写七个方法。Vue 3 改用 Proxy,能在访问时才递归(惰性),并且天然支持新增/删除属性、数组索引赋值、Map/Set 等集合类型。细节见 前端-06-Vue。
3.12 Object.entries / Object.fromEntries / Object.is
// 运行环境:Node.js(实测 v24.18.0)或浏览器控制台
// ① entries:对象 → [键, 值] 数组(顺序:整数键升序在前,其余按插入顺序)
const source = { b: 2, a: 1, 10: 'ten', 2: 'two' };
console.log(Object.entries(source)); // [ ['2','two'], ['10','ten'], ['b',2], ['a',1] ]
console.log(Object.values(source), Object.keys(source));
// ② fromEntries:数组 → 对象,与 entries 互为逆运算
const entries = Object.entries({ x: 1, y: 2 });
console.log(Object.fromEntries(entries)); // { x: 1, y: 2 }
console.log(Object.fromEntries(new Map([['k', 'v']]))); // { k: 'v' }
// 实战:过滤对象字段、把数组转成字典
const picked = Object.fromEntries(entries.filter(([k]) => k !== 'x'));
const byId = Object.fromEntries([{ id: 'a', n: 1 }, { id: 'b', n: 2 }].map((i) => [i.id, i]));
console.log(picked, byId);
// ③ Object.is:SameValue 算法,与 === 只有两处差异
console.log(Object.is(NaN, NaN), NaN === NaN); // true false
console.log(Object.is(-0, 0), -0 === 0); // false true
console.log(Object.is('1', 1), Object.is({}, {})); // false false —— 对象仍比引用
需求 推荐 说明 遍历对象的键值 Object.entries配合 for (const [k, v] of ...) 数组/映射转对象 Object.fromEntries与 entries/Map 无缝衔接 判断 NaN Object.is(x, NaN) 或 Number.isNaN(x)x === NaN 永远为 false区分 +0 / -0 Object.is只有需要区分符号零时才用 判断普通相等 ===99% 的场景都用它
3.13 Array.prototype 新增方法
// 运行环境:Node.js(实测 v24.18.0)或浏览器控制台
// ① includes:用 SameValueZero 比较,能正确找到 NaN
console.log([1, 2].includes(2), [NaN].includes(NaN), [NaN].indexOf(NaN)); // true true -1
// 对对象仍然是引用比较
const target = { id: 1 };
console.log([{ id: 1 }].includes(target), [{ id: 1 }].includes({ id: 1 })); // false false
// ② flat:按深度展平,默认 1 层;flat(Infinity) 展平到底
const nested = [1, [2, [3, [4]]]];
console.log(nested.flat()); // [1, 2, [3, [4]]]
console.log(nested.flat(2)); // [1, 2, 3, [4]]
console.log(nested.flat(Infinity)); // [1, 2, 3, 4]
// ③ flatMap = map + flat(1),适合"一变多"的映射
console.log([1, 2].flatMap((v) => [v, v * 10])); // [1, 10, 2, 20]
console.log(['a b', 'c'].flatMap((s) => s.split(' '))); // ['a', 'b', 'c']
console.log([1, 2].flatMap((v) => [[v]])); // [[1], [2]] —— 只展平一层
// ④ at:支持负数索引,等价关系为 at(-1) 取第 n-1 个元素(n 为长度)
const arr = [10, 20, 30];
console.log(arr.at(0), arr.at(-1), arr.at(-2)); // 10 30 20
console.log(arr[arr.length - 1] === arr.at(-1)); // true
// ⑤ findLast / findLastIndex:从后往前找(ES2023)
const logs = [{ lv: 'info' }, { lv: 'error' }, { lv: 'warn' }];
console.log(logs.findLast((l) => l.lv !== 'info')); // { lv: 'warn' }
console.log([1, 2, 3, 4].findLastIndex((n) => n % 2 === 0)); // 3
// ⑥ 不改原数组的新方法:toSorted / toReversed / toSpliced / with
const nums = [3, 1, 2];
console.log(nums.toSorted(), nums); // [1, 2, 3] [3, 1, 2] —— 原数组不动
console.log(nums.with(0, 99)); // [99, 1, 2]
includes 判定的其实是"存在性",用数学语言写出来更清楚(设数组为 ):
其中 SameValueZero 是规范里的比较算法:与 === 相同,但把 NaN 视为等于自身(这就是 [NaN].includes(NaN) 为真、[NaN].indexOf(NaN) 为 -1 的原因)。因为要逐个比较,includes 是 ;而 Set.prototype.has 走哈希表,约为 ——所以"反复判断某个值是否存在"时,应该先把数组转成 Set。
方法 复杂度 与旧写法的关系 includesindexOf(x) !== -1 的替代,能处理 NaNflat(d)递归 concat 的替代;会丢弃稀疏数组的空洞 flatMap(f)map(f).flat(),但只需遍历一次at(i)arr[i < 0 ? arr.length + i : i]findLast(f)从右往左找第一个满足条件的元素 toSorted() 等 / 不改原数组,适合函数式与响应式框架
flat 会丢掉稀疏数组的"空洞"
[1, , 3].flat() 得到 [1, 3],长度从 3 变成 2,而 map/forEach 会跳过空洞、保留长度。处理稀疏数组时要特别小心。
3.14 可选链 ?. 与空值合并 ??
// 运行环境:Node.js(实测 v24.18.0)或浏览器控制台
const cfg = { retry: 0, name: '', nested: null, fn: null };
// ① ?. 只在遇到 null / undefined 时短路,其余值(0、''、false)正常继续
console.log(cfg?.retry); // 0
console.log(cfg?.nested?.deep); // undefined —— 链式短路,不报错
console.log(cfg.missing?.x); // undefined
console.log(cfg.fn?.()); // undefined —— 函数调用也可选
console.log([1, 2]?.[0]); // 1 —— 下标访问写成 ?.[]
// ② ?? 只在 null / undefined 时兜底,保留 0 与 ''(与 || 的关键差异)
console.log(cfg.retry || 3, cfg.retry ?? 3); // 3 0
console.log(cfg.name || '匿名', cfg.name ?? '匿名'); // 匿名 ('' 被 ?? 保留)
// ③ 短路是"真短路":右边不会被求值
console.log(1 || console.log('|| 右侧未求值')); // 1
console.log(null ?? console.log('?? 右侧被求值')); // undefined,并打印提示
// ④ 与解构默认值配合:处理接口返回的可选字段
const res = { data: { list: null } };
const items = res.data?.list ?? [];
console.log(items); // []
五个高频错误
1. obj?.a.b 不保护 b:如果 obj.a 存在但为 null,读 .b 仍然报错,必须写 obj?.a?.b。
2. 不能作为赋值目标:obj?.a = 1、a?.b++ 都是语法错误。
3. ?? 不能与 || / && 无括号混用:a ?? b || c 抛 SyntaxError,要写 (a ?? b) || c。
4. 把 ?. 当成万能防错:它只处理"值缺失",不处理类型错误("abc"?.toFixed() 依旧报错)。
5. 误以为 ?? 能兜住 NaN:NaN ?? 0 结果是 NaN,要用 Number.isNaN 判断。
3.15 String.prototype.replaceAll / padStart
// 运行环境:Node.js 15+(实测 v24.18.0)或现代浏览器
// ① replace 只替换第一个(字符串参数时),replaceAll 替换全部
console.log('a-b-c'.replace('-', '+')); // a+b-c
console.log('a-b-c'.replaceAll('-', '+')); // a+b+c
// 用正则时:replaceAll 要求必须带 g 标志,否则 TypeError
console.log('a-b'.replaceAll(/-/g, '+')); // a+b
// try { 'a-b'.replaceAll(/-/, '+'); } catch (e) { console.log(e.constructor.name); } // TypeError
// ② padStart / padEnd:对齐、补零、格式化
console.log('7'.padStart(3, '0')); // 007
console.log(''.padStart(5, '*')); // *****
console.log('abc'.padStart(2, '0')); // abc —— 已经够长就不会截断
console.log('id'.padEnd(6, '.')); // id....
// 表头对齐的经典场景
const rows = [['商品', 12.5], ['税', 1.25]];
for (const [label, amount] of rows) {
console.log(label.padEnd(8, ' ') + String(amount).padStart(8, ' '));
}
方法 作用 注意 replace(搜索, 替换)替换第一个匹配 传字符串时只换一处,是常见 bug 来源 replaceAll(搜索, 替换)替换全部匹配 传正则必须带 g;替换串里的 $&`、`$1 等仍有特殊含义 padStart(n, s)在开头补到长度 n 已超过 n 不截断;s 不足会重复,超出会截断 padEnd(n, s)在末尾补到长度 n 同上
四、怎么用:一个端到端的小工具
下面把解构、展开、Map、Symbol.iterator、生成器、Proxy 组合成一个"带校验与缓存的表单数据处理"示例。
运行环境:Node.js 18+(本机实测 v24.18.0);浏览器控制台同样可运行(不含 Node 专有 API)。
// 运行环境:Node.js 18+(实测 v24.18.0)
// ① 用生成器 + 迭代协议定义一个"按批次产出"的数据源
function* chunked(items, size = 2) {
for (let i = 0; i < items.length; i += size) {
yield items.slice(i, i + size); // 每次交出一批,调用方自己决定何时取下一批
}
}
// ② 用 Map + Proxy 做一个带校验和去重的表单校验器
function createValidator(rules) {
const errors = new Map(); // key 是字段名,value 是错误信息数组
const state = { values: {}, touched: new Set() };
const api = {
set(field, value) {
state.values[field] = value;
state.touched.add(field);
const fieldRules = rules[field] ?? [];
const failed = fieldRules.filter((rule) => !rule.check(value)).map((rule) => rule.message);
failed.length ? errors.set(field, failed) : errors.delete(field);
return this;
},
get errors() { return Object.fromEntries(errors); }, // Map → 普通对象,便于打印
get valid() { return errors.size === 0; },
batch(entries) { // 批量写入,演示生成器分批
for (const chunk of chunked(entries, 2)) { // 每批 2 条记录
for (const [field, value] of chunk) api.set(field, value);
}
return this;
},
};
// ③ 只读保护 + 未知动作报错:Proxy 负责"边界",业务逻辑仍在 api 上
return new Proxy(api, {
get(target, prop, receiver) {
if (typeof prop === 'string' && !(prop in target) && !prop.startsWith('_')) {
throw new TypeError(`不支持的操作:${prop}`);
}
return Reflect.get(target, prop, receiver);
},
set() { throw new TypeError('校验器是只读的,请使用 set(field, value)'); },
});
}
const form = createValidator({
email: [
{ check: (v) => typeof v === 'string' && v.includes('@'), message: '邮箱格式不正确' },
],
age: [
{ check: (v) => Number.isInteger(v) && v >= 18, message: '必须年满 18 岁' },
],
});
form.set('email', 'ada@example.com').set('age', 36);
console.log('第一次:', form.valid, form.errors); // true {}
form.set('age', 12);
console.log('第二次:', form.valid, form.errors); // false { age: ['必须年满 18 岁'] }
form.batch([['email', 'bad'], ['age', 20]]); // 走生成器分批写入
console.log('第三次:', form.errors); // { email: ['邮箱格式不正确'] }
try { form.reset(); } catch (e) { console.log('拦截未知操作:', e.message); }
try { form.valid = true; } catch (e) { console.log('拦截写入:', e.message); }
关键点解释:
chunked 生成器让"分批"这件事对外表现为一个普通可迭代对象,调用方用 for...of 就行;注意它接收的是 [键, 值] 数组(生成器内部依赖 items.length),传普通对象会因为 length 是 undefined 而一条都不处理;
errors 内部是 Map(增删频繁、键是字符串也一样顺手),对外用 Object.fromEntries 转成普通对象便于查看;
Proxy 的 get 陷阱负责接口边界(未知方法立刻报错,而不是等到调用时才发现是 undefined),set 陷阱把"整体替换"这种误用挡掉;
Reflect.get(target, prop, receiver) 转发时把 receiver 一并传下去,getter 里的 this 才会指向代理而不是原对象。
五、ES6+ 常用特性速查表
特性 语法 引入版本 一句话用途 常见坑 块级作用域 let / constES2015 替代 var TDZ;const 不冻结对象内容 箭头函数 (a) => a * 2ES2015 回调、继承外层 this 不能 new、无 arguments 模板字符串 ` a${b} ` ES2015 插值与多行文本 标签模板的第一个参数是数组 解构 const { a } = oES2015 按形状取值 解构 null/undefined 会抛错;{ 开头要加括号 默认参数 f(a = 1)ES2015 只在 undefined 时兜底 null 不触发默认值剩余 / 展开 ...ES2015(对象 ES2018) 收集与铺开 浅拷贝;伪数组要用 Array.from 简写 { a, b() {} }ES2015 少写重复代码 方法简写有动态 this 计算属性名 { [k]: v }ES2015 动态键 k 为 undefined 时会变成字符串 'undefined'for...offor (const v of it)ES2015 统一遍历 普通对象不可迭代 迭代协议 Symbol.iterator / next()ES2015 自定义遍历 提前 break 会调用 return() 生成器 function* / yieldES2015 惰性序列、流程控制 首次 next() 的参数被丢弃 SymbolSymbol('d')ES2015 唯一键、语言钩子 不是私有属性 Map / Setnew Map() / new Set()ES2015 任意键字典 / 去重集合 转对象时键会变字符串 WeakMap / WeakSetnew WeakMap()ES2015 不阻止 GC 的关联数据 键必须是对象;不可迭代、无 size Proxy / Reflectnew Proxy(t, traps)ES2015 拦截对象操作 有不变量约束;转发要用 Reflect Object.entries / valuesObject.entries(o)ES2017 对象 → 数组 整数键会排到前面 Object.fromEntriesObject.fromEntries(e)ES2019 数组 → 对象 与 entries 互逆 Object.isObject.is(a, b)ES2015 SameValue 比较 与 === 只在 NaN/-0 上不同 幂运算符 a ** bES2016 幂运算 与 Math.pow 等价 includesarr.includes(x)ES2016 包含判断 能找 NaN;对象是引用比较 async / awaitawait pES2017 写同步风格的异步 串行 await 会变慢,用 Promise.all padStart / padEnd'7'.padStart(3,'0')ES2017 对齐与补位 超长不截断 对象展开 { ...o }ES2018 浅拷贝与合并 不复制原型、getter 会求值 异步迭代 for await (const x of it)ES2018 逐个处理异步数据 只能用在 async 函数里 flat / flatMaparr.flat(2)ES2019 展平数组 会丢稀疏空洞;flatMap 只展平一层 trimStart / trimEnds.trimStart()ES2019 去首/尾空白 老环境不支持 可选 catch 绑定 catch {}ES2019 不关心错误对象时省掉参数 丢失堆栈信息,调试时先别省 可选链 a?.bES2020 安全访问 a?.b.c 不保护 c;不能赋值空值合并 a ?? bES2020 只兜底 null/undefined 不能与 ` /&&` 无括号混用BigInt10nES2020 任意精度整数 不能与 Number 混算 Promise.allSettledawait Promise.allSettled(ps)ES2020 等全部结束(含失败) 结果是 {status, value/reason} 动态导入 await import('./m.js')ES2020 按需加载与代码分割 变量拼路径会打包整个目录 globalThisglobalThisES2020 跨环境的全局对象 老环境需 polyfill replaceAlls.replaceAll('a','b')ES2021 全部替换 正则必须带 g Promise.anyawait Promise.any(ps)ES2021 取第一个成功 全失败抛 AggregateError 逻辑赋值 a ??= bES2021 缺省赋值 `a = b 会覆盖 0/''` 数字分隔符 1_000_000ES2021 大数字可读 只是书写形式 顶层 await 模块内 await ES2022 模块初始化等待异步 只在 ESM 顶层可用 class 私有字段#xES2022 真正的私有 不能在类外访问,反射也拿不到 Array.prototype.atarr.at(-1)ES2022 负数索引 是方法不是属性:arr.at 不加括号拿到的是函数 Object.hasOwnObject.hasOwn(o,'k')ES2022 判断自有属性 替代 hasOwnProperty.call findLastarr.findLast(f)ES2023 从后往前找 找不到返回 undefined 非破坏性数组方法 arr.toSorted()ES2023 不改原数组 返回值是新数组,别忽略 Object.groupByObject.groupBy(a, f)ES2024 按规则分组 返回值是"无原型对象" Promise.withResolversPromise.withResolvers()ES2024 拿到 resolve/reject 记得处理未使用的 Promise 迭代器辅助方法 it.map(f).toArray()ES2025 迭代器上直接链式操作 需要较新运行时 Set 集合运算a.union(b)ES2025 交并差 同样需要较新运行时
上表版本归属与可用性以 MDN 与 TC39 官方最新文档为准;投产前请确认目标浏览器/Node 版本,或用 caniuse、node.green 一类兼容性表核对。
六、注意事项与常见坑
ES6+ 的十三个高频陷阱
1. 把展开当深拷贝:{ ...a } 与 [...a] 只复制一层,嵌套对象仍共享引用。
2. 解构 null/undefined:const { a } = null 直接抛 TypeError,接口数据要写 = {} 兜底。
3. 以 { 开头的解构语句:必须加括号 ({ a } = obj),否则被解析成块语句。
4. [...伪数组] 报 not iterable:只有 length 的对象要用 Array.from。
5. 默认参数只认 undefined:传 null 时默认值不生效,这是"表单清空"类 bug 的常见来源。
6. Map 转对象的键会变字符串:Object.fromEntries(map) 之后对象键丢失类型信息。
7. WeakMap 用原始值做键:抛 TypeError: Invalid value used as weak map key。
8. 指望 WeakMap 可枚举:没有 size、keys()、forEach,这是设计使然。
9. 生成器第一次 next(v) 的参数被丢弃:v 会赋给"上一个 yield",而第一个 yield 之前没有上一个。
10. for...in 遍历数组:拿到的是字符串下标,还会带上原型链上可枚举的属性;数组用 for...of。
11. replace 只换第一个:想全换用 replaceAll 或带 g 的正则。
12. arr.at 忘记加括号:arr.at 是函数本身,arr.at(-1) 才是取值。
13. 给"期望数组"的函数传了对象:例如 for (let i = 0; i < items.length; i += size) 收到对象时,items.length 是 undefined,循环体一次都不执行且不报错,属于最难查的"静默无输出"类 bug(本篇第四节示例就踩过这个坑)。
三个"看起来能用、实际会崩"的写法
- 在 Proxy 的 set 陷阱里写 obj[prop] = value:会再次触发自己的陷阱,造成无限递归(栈溢出)。必须用 Reflect.set。
- 用 Object.fromEntries 处理"键可能是 __proto__"的数据:可能污染原型,要显式过滤或用 Map。
- 在 flat(Infinity) 之后假设长度不变:稀疏数组的空洞会被丢弃,索引与长度都可能与预期不符。
实践建议
- 现代项目统一用 const(需要重新赋值才用 let),彻底不用 var;
- 接口数据一律用可选链 + ?? + 解构默认值三件套处理,代码里不出现"防御性 if 地狱";
- 需要"对象做键"就上 Map,需要"给对象挂附加数据且不想泄漏"就上 WeakMap;
- 只读语义优先用非破坏性方法(toSorted、with、flatMap),减少共享可变状态;
- 新语法上线前,用 Array.prototype.at、groupBy 这类较新 API 时先确认目标运行时版本。
七、练习题
练习 1(解构与默认值)
给定 const res = { code: 0, data: { user: { name: '', tags: null } } },用一条解构语句取出 code、name(缺省为 '匿名')、tags(缺省为空数组),并为整个链路提供安全兜底。写出代码并说明为什么 name 取到的是 '' 而不是 '匿名'。
练习 2(展开与浅拷贝)
写一个函数 mergeConfig(defaults, userConfig),要求:① 不修改任何入参;② 第二层的 headers 对象要合并而不是整体替换;③ 用一行代码调用验证。写出实现,并解释为什么单靠 { ...defaults, ...userConfig } 做不到第②点。
练习 3(迭代协议)
实现一个 countdown(n) 对象:可被 for...of 遍历,依次产出 ;用 break 提前退出时要在控制台打印 已取消。要求不使用生成器,只用手写 [Symbol.iterator]。
练习 4(生成器流水线)
用生成器实现三个函数:naturals() 产出无限自然数、take(it, n) 取前 n 个、filter(it, pred) 过滤。把它们串起来取出"前 5 个偶数",并说明为什么这个组合不会死循环。
练习 5(Map 与 WeakMap 选型)
你要给一批 DOM 节点(或普通对象)缓存"上一次渲染的状态":① 用 Map 实现;② 用 WeakMap 实现。然后用 200 字说明:在"节点会被反复创建与删除"的场景下,哪一种会导致内存泄漏、为什么,以及为什么 WeakMap 不提供 size。
练习 6(Proxy 校验)
用 Proxy 写一个 createModel(schema):访问未声明字段时抛 TypeError,给字段赋错类型时抛 TypeError,并保证 JSON.stringify(model) 得到的是普通对象结构。写出实现与三个测试用例,说明你为什么在陷阱里用 Reflect。
八、常见问题 FAQ
我需要把 ES6 特性全部学会才能写项目吗?
不需要。按"每天都会用"排序,优先级最高的是:let/const、箭头函数、模板字符串、解构、展开/剩余、可选链与空值合并、async/await、Map/Set。迭代器、生成器、Proxy/Reflect、Symbol 属于"理解了会显著提升上限"的部分:不写框架时可以不懂,但看不懂 Vue 3 响应式、Redux 中间件、for await 的源码就都卡在这里。
用新语法会不会导致老浏览器跑不了?
取决于"语法"还是"API"。语法(解构、箭头函数、?.)可以由 Babel / TypeScript 转译成老语法;API(Map、Proxy、WeakRef、Object.groupBy)无法转译,只能靠 polyfill(且 Proxy 这类根本没法 polyfill),必须按目标环境决定。工程做法是:用 browserslist 声明目标范围,让构建工具自动决定转译与 polyfill 策略,详见 前端-05-TypeScript 与 前端-08-构建工具-Vite与Webpack。
Map 和普通对象到底该用哪个?
判据是"键的性质":键是固定的、已知的字段名(配置、接口返回的实体)→ 普通对象,JSON.stringify 直接可用、写法更短;键是动态的、可能很多、可能是对象/数字(缓存、字典、计数器、分组)→ Map,它有 size、严格插入顺序、任意键类型,且不会与原型上的属性撞名(不必担心 __proto__)。
WeakMap 能当缓存用吗?
能,但只适合"键会自然消失"的缓存:键对象被回收时缓存条目自动清理,不需要手动淘汰逻辑。它不能做容量控制(没有 size,无法实现 LRU),也不适合"键是字符串"的场景(字符串做不了 WeakMap 键,要用 Map 加淘汰策略)。生产环境常见的折中做法是:Map + 上限 + WeakRef(ES2021,以官方最新文档为准)组合,或者直接用成熟的缓存库。
相关笔记
- JavaScript-01-基础语法与类型 ——
let/const、TDZ、原始类型,本篇 3.6 与 3.14 节的前置知识
- JavaScript-02-函数与作用域 —— 箭头函数、
this、闭包的完整机制,本篇只做对比表
- JavaScript-03-对象与原型链 —— 属性描述符、原型链,理解
Proxy 与对象展开的前提
- JavaScript-04-异步编程 ——
Promise、async/await 与事件循环,本篇生成器接管异步的原理在这一篇
- JavaScript-06-模块化与工程化 —— 顶层
await、动态 import()、打包与 tree-shaking
- 前端-05-TypeScript —— 这些新语法在类型系统中的对应写法与编译目标配置
- 前端-06-Vue —— Vue 3 用
Proxy 重写响应式系统,对应本篇 3.11 节的示例
- 前端-07-React —— 解构、展开与不可变更新在 JSX 中的日常用法
- Python-07-进阶特性 —— 与 Python 的生成器、装饰器、迭代协议对照阅读
- CSharp-06-现代CSharp特性 —— C# 的
yield return、模式匹配与属性简写的横向对照
参考来源
- ECMAScript 语言规范(TC39 官方最新版)
- TC39 官方流程文档(Stage 0–4 与年度发布)
- Node.js 官方文档(各版本对语言特性的支持情况)
- MDN:解构赋值
- MDN:展开语法
- MDN:模板字符串
- MDN:箭头函数
- MDN:
let / const
- MDN:
Symbol
- MDN:
Symbol.iterator
- MDN:迭代协议
- MDN:
function 生成器
- MDN:
for...of
- MDN:
Map / Set
- MDN:
WeakMap / WeakSet
- MDN:
Proxy / Reflect
- MDN:
Object.entries() / Object.fromEntries() / Object.is()
- MDN:
Array.prototype.includes() / flat() / flatMap()
- MDN:
Array.prototype.at() / findLast()
- MDN:可选链运算符
?. / 空值合并运算符 ??
- MDN:
String.prototype.replaceAll() / padStart()
- MDN:迭代器辅助方法
Iterator.prototype.map()
- MDN:
Set.prototype.union()
- MDN:
Object.groupBy()
- MDN:
Promise.withResolvers()
- 现代 JavaScript 教程:解构赋值
- 现代 JavaScript 教程:剩余参数与展开语法
- 现代 JavaScript 教程:可迭代对象
- 现代 JavaScript 教程:生成器
- 现代 JavaScript 教程:Map 与 Set
- 现代 JavaScript 教程:WeakMap 与 WeakSet
- 现代 JavaScript 教程:Proxy 与 Reflect
- 现代 JavaScript 教程:Symbol 类型
- 现代 JavaScript 教程:可选链
- 现代 JavaScript 教程:空值合并运算符
- 说明:各特性的版本归属、Stage 阶段、目标环境可用性都属于版本敏感信息,以 MDN 与 TC39 官方最新文档为准。 本篇代码除特别标注外均在本机 Node.js v24.18.0 上实测通过。