w wyl123ly 的博客
MD

JavaScript-07-ES6新特性

65 KB 2026.10.11 原文件

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,官方文档里更倾向用年份。

版本俗称代表性新增(只列常用项)
ES2015ES6let/const、箭头函数、class、模板字符串、解构、默认/剩余/展开、for...of、迭代器、生成器、Promise、Symbol、Map/Set/WeakMap/WeakSet、Proxy/Reflect、模块语法、Number.isNaN 等
ES2016ES7幂运算符 **、Array.prototype.includes
ES2017ES8async/await、Object.values/entries、String.prototype.padStart/padEnd、Object.getOwnPropertyDescriptors
ES2018ES9对象展开/剩余、异步迭代 for await...of、Promise.prototype.finally、正则命名捕获组与 s(dotAll)标志
ES2019ES10Array.prototype.flat/flatMap、Object.fromEntries、String.prototype.trimStart/trimEnd、可选 catch 绑定、Symbol.prototype.description
ES2020ES11可选链 ?.、空值合并 ??、BigInt、Promise.allSettled、globalThis、动态 import()、import.meta、String.prototype.matchAll
ES2021ES12String.prototype.replaceAll、Promise.any、逻辑赋值 `=/&&=/??=、WeakRef、数字分隔符 1_000_000`
ES2022ES13顶层 await、class 字段与私有 # 字段、静态初始化块、Array.prototype.at、Object.hasOwn、Error 的 cause
ES2023ES14findLast/findLastIndex、不改原数组的 toSorted/toReversed/toSpliced/with、Hashbang 语法
ES2024ES15Object.groupBy/Map.groupBy、Promise.withResolvers、正则 v 标志、可调整大小的 ArrayBuffer
ES2025ES16迭代器辅助方法(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、块级作用域、TDZvar 的变量提升与循环陷阱需要理解 TDZ,混用 var 更容易迷惑
从"值"走向"协议"迭代器协议、可迭代协议、生成器、Symbolfor 循环各写一套,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-基础语法与类型。这里只需记住三条:

  1. let / const 是块级作用域,{ }、for、if 都能形成作用域;
  2. 声明前访问进入暂时性死区(TDZ),抛 ReferenceError(这是好事,能提早暴露 bug);
  3. 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.xReflect.get
set写入属性 obj.x = vReflect.set
has'x' in objReflect.has
deletePropertydelete obj.xReflect.deleteProperty
ownKeysObject.keys、Reflect.ownKeysReflect.ownKeys
getOwnPropertyDescriptorObject.getOwnPropertyDescriptorReflect.getOwnPropertyDescriptor
definePropertyObject.definePropertyReflect.defineProperty
getPrototypeOf / setPrototypeOf读取/设置原型Reflect.getPrototypeOf / Reflect.setPrototypeOf
isExtensible / preventExtensions可扩展性检查与冻结同名方法
apply函数调用 fn()Reflect.apply
constructnew 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 无缝衔接
判断 NaNObject.is(x, NaN) 或 Number.isNaN(x)x === NaN 永远为 false
区分 +0 / -0Object.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 的替代,能处理 NaN
flat(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替代 varTDZ;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)ES2015SameValue 比较与 === 只在 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模块内 awaitES2022模块初始化等待异步只在 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、模式匹配与属性简写的横向对照

参考来源