---
title: JavaScript-07-ES6新特性
aliases:
  - ES6 新特性
  - ES2015 与年度新特性
  - JavaScript ES6 Features
tags:
  - 编程语言/JavaScript
  - 类型/教程
created: 2026-10-11
updated: 2026-10-11
level: 入门
prerequisites:
  - "[[JavaScript-01-基础语法与类型]]"
  - "[[JavaScript-02-函数与作用域]]"
sources:
  - https://tc39.es/ecma262/
  - https://tc39.es/process-document/
  - https://nodejs.org/docs/latest/api/
  - https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment
  - https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Operators/Spread_syntax
  - https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Template_literals
  - https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Functions/Arrow_functions
  - https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Statements/let
  - https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Statements/const
  - https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Symbol
  - https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Symbol/iterator
  - https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Iteration_protocols
  - https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Statements/function*
  - https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Statements/for...of
  - https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Map
  - https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Set
  - https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/WeakMap
  - https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/WeakSet
  - https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Proxy
  - https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Reflect
  - https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Object/entries
  - https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Object/fromEntries
  - https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Object/is
  - https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Array/includes
  - https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Array/flat
  - https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Array/flatMap
  - https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Array/at
  - https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Array/findLast
  - https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Operators/Optional_chaining
  - https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Operators/Nullish_coalescing
  - https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/String/replaceAll
  - https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/String/padStart
  - https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Iterator/map
  - https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Set/union
  - https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Object/groupBy
  - https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Promise/withResolvers
  - https://zh.javascript.info/destructuring-assignment
  - https://zh.javascript.info/rest-parameters-spread
  - https://zh.javascript.info/iterable
  - https://zh.javascript.info/generators
  - https://zh.javascript.info/map-set
  - https://zh.javascript.info/weakmap-weakset
  - https://zh.javascript.info/proxy
  - https://zh.javascript.info/symbol
  - https://zh.javascript.info/optional-chaining
  - https://zh.javascript.info/nullish-coalescing-operator
---

# JavaScript-07-ES6新特性

> [!abstract] 本篇讲什么
> **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` |

> [!warning] 上表只用于建立"时间感"，不要背
> 版本归属会随提案进度变动，个别特性还可能被撤回或改名。需要精确信息时查两处：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） | 至少两个独立实现通过测试，纳入下一年度标准 | 可用（仍需看目标环境） |

> [!tip] 工程上的判断标准
> **"进 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 | 想拦截对象操作只能靠约定或改写方法 | 性能与调试复杂度上升，拦截器是"隐形"的 |

> [!important] 一句话抓住本质
> ES6 不是"加了几个语法糖"，而是**给 JavaScript 补上了三样东西**：块级作用域（作用域模型）、迭代协议（统一的遍历抽象）、元编程能力（`Symbol` 与 `Proxy`）。`Promise`、生成器、`for...of` 全都建立在这三样之上。

---

## 三、核心内容

### 3.1 解构赋值（Destructuring）

解构是"按模式取值"：左边写形状，右边写数据源。

```js
// 运行环境：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
}
```

> [!note] 解构的返回值与"无声明赋值"陷阱
> - 解构表达式本身返回**右边那个值**，所以 `const o = { a: 1 }; const r = ({ a } = o);` 里 `r === o`。
> - 以 `{` 开头的语句会被当成块语句，**必须加括号**：`({ a } = obj);`。
> - 解构 `null` 或 `undefined` 会抛 `TypeError`；对"可能不存在"的层级要给默认值 `= {}`。

### 3.2 展开与剩余运算符 `...`

同一个 `...`，在**调用/字面量里是展开**（spread），在**赋值/参数位置是剩余**（rest）。

```js
// 运行环境：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` 和下标的对象只能用它 |

> [!warning] 展开是浅拷贝，别拿它做深拷贝
> `{ ...obj }` 与 `[...arr]` 都只复制第一层。要真正深拷贝，可用 `structuredClone(obj)`（现代运行时与浏览器已内置）或成熟的深拷贝库；`JSON.parse(JSON.stringify(obj))` 会丢 `undefined`、`Date`、`Map` 等，不要作为通用方案。

### 3.3 模板字符串（Template Literal）

```js
// 运行环境：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}</td><td>${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) => ({
  '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;',
}[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>&lt;script&gt;alert(1)&lt;/script&gt;</p>
```

### 3.4 简写语法（Shorthand）

```js
// 运行环境：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());
```

> [!warning] 简写会让"函数名/属性名"与来源耦合
> `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：唯一且不会被撞名的属性键

```js
// 运行环境：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` | 指定派生对象的构造函数 |

> [!warning] 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`。

```js
// 运行环境：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`。

```js
// 运行环境：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
```

> [!note] 生成器与迭代器的关系
> **生成器函数返回的对象自动实现了两个协议**，因此你不需要手写 `next()`。反过来，`async` 函数可以看作"生成器 + 自动驱动"的语法糖：`yield` 换成 `await`，把 Promise 的 then 链交给引擎处理。异步的完整机制见 [[JavaScript-04-异步编程]]。

### 3.10 `Map` / `Set` / `WeakMap` / `WeakSet`

```js
// 运行环境：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（实测）
```

| 对比项 | 普通对象 `{}` | `Map` | `Set` | `WeakMap` / `WeakSet` |
|---|---|---|---|---|
| 键的类型 | 只能是字符串或 Symbol | **任意类型**（含对象、函数、`NaN`） | 元素即键 | **只能是对象**（否则 `TypeError`） |
| 迭代顺序 | 整数键升序在前，其余按插入顺序 | **严格插入顺序** | 插入顺序 | **不可迭代** |
| 取大小 | `Object.keys(o).length`，$O(n)$ | `size`，$O(1)$ | `size` | **没有 `size`** |
| 查找复杂度 | 属性查找接近 $O(1)$，但键被转成字符串 | `get` 约 $O(1)$ | `has` 约 $O(1)$，而 `Array.includes` 是 $O(n)$ | `has` 约 $O(1)$ |
| 键是否阻止垃圾回收 | 是 | 是 | 是 | **否**（弱引用） |
| 可枚举/可序列化 | `JSON.stringify` 直接支持 | 需 `Object.fromEntries` 转换 | 需展开成数组 | 都不支持 |
| 典型用途 | 结构化的数据、配置 | 频繁增删的字典、对象做键 | 去重、集合运算 | 给对象挂"私有"数据、缓存、DOM 元数据 |

> [!important] Weak 版本存在的唯一理由：不阻止垃圾回收
> `Map` 持有键的强引用：只要 `Map` 活着，键对象就永远不会被回收——把 DOM 节点当键缓存，页面就会持续泄漏内存。`WeakMap` 的键是弱引用，**对象被回收时对应的条目自动消失**，因此引擎不需要（也不允许）提供 `size`、迭代和 `clear`：这些 API 会暴露"当前有多少条"这种依赖 GC 时机的不确定信息。
> 实践中的典型用法：给 DOM 节点挂状态、实现"每个对象一份"的私有数据、给对象做无泄漏缓存。

### 3.11 `Proxy` 与 `Reflect`：把拦截写进语言

`Proxy` 用拦截器（trap，也叫"陷阱"）包住目标对象，任何对代理的操作都先经过你。

```js
// 运行环境：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.get` |
| `set` | 写入属性 `obj.x = v` | `Reflect.set` |
| `has` | `'x' in obj` | `Reflect.has` |
| `deleteProperty` | `delete obj.x` | `Reflect.deleteProperty` |
| `ownKeys` | `Object.keys`、`Reflect.ownKeys` | `Reflect.ownKeys` |
| `getOwnPropertyDescriptor` | `Object.getOwnPropertyDescriptor` | `Reflect.getOwnPropertyDescriptor` |
| `defineProperty` | `Object.defineProperty` | `Reflect.defineProperty` |
| `getPrototypeOf` / `setPrototypeOf` | 读取/设置原型 | `Reflect.getPrototypeOf` / `Reflect.setPrototypeOf` |
| `isExtensible` / `preventExtensions` | 可扩展性检查与冻结 | 同名方法 |
| `apply` | 函数调用 `fn()` | `Reflect.apply` |
| `construct` | `new fn()` | `Reflect.construct` |

> [!warning] 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)` 也可能触发陷阱。

> [!note] 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`

```js
// 运行环境：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` 新增方法

```js
// 运行环境：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` 判定的其实是"存在性"，用数学语言写出来更清楚（设数组为 $a_0, a_1, \dots, a_{n-1}$）：

$$
\text{includes}(x) \;=\; \exists\, i \in [0,\, n):\ \text{SameValueZero}(a_i,\, x)
$$

其中 SameValueZero 是规范里的比较算法：与 `===` 相同，但把 `NaN` 视为等于自身（这就是 `[NaN].includes(NaN)` 为真、`[NaN].indexOf(NaN)` 为 `-1` 的原因）。因为要逐个比较，`includes` 是 $O(n)$；而 `Set.prototype.has` 走哈希表，约为 $O(1)$——所以"反复判断某个值是否存在"时，应该先把数组转成 `Set`。

| 方法 | 复杂度 | 与旧写法的关系 |
|---|---|---|
| `includes` | $O(n)$ | `indexOf(x) !== -1` 的替代，能处理 `NaN` |
| `flat(d)` | $O(n)$ | 递归 `concat` 的替代；会丢弃稀疏数组的空洞 |
| `flatMap(f)` | $O(n)$ | `map(f).flat()`，但只需遍历一次 |
| `at(i)` | $O(1)$ | `arr[i < 0 ? arr.length + i : i]` |
| `findLast(f)` | $O(n)$ | 从右往左找第一个满足条件的元素 |
| `toSorted()` 等 | $O(n \log n)$ / $O(n)$ | 不改原数组，适合函数式与响应式框架 |

> [!warning] `flat` 会丢掉稀疏数组的"空洞"
> `[1, , 3].flat()` 得到 `[1, 3]`，长度从 3 变成 2，而 `map`/`forEach` 会跳过空洞、保留长度。处理稀疏数组时要特别小心。

### 3.14 可选链 `?.` 与空值合并 `??`

```js
// 运行环境：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);               // []
```

> [!warning] 五个高频错误
> 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`

```js
// 运行环境：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）。**

```js
// 运行环境：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` / `const` | ES2015 | 替代 `var` | TDZ；`const` 不冻结对象内容 |
| 箭头函数 | `(a) => a * 2` | ES2015 | 回调、继承外层 `this` | 不能 `new`、无 `arguments` |
| 模板字符串 | `` `a${b}` `` | ES2015 | 插值与多行文本 | 标签模板的第一个参数是数组 |
| 解构 | `const { a } = o` | ES2015 | 按形状取值 | 解构 `null`/`undefined` 会抛错；`{` 开头要加括号 |
| 默认参数 | `f(a = 1)` | ES2015 | 只在 `undefined` 时兜底 | `null` 不触发默认值 |
| 剩余 / 展开 | `...` | ES2015（对象 ES2018） | 收集与铺开 | **浅拷贝**；伪数组要用 `Array.from` |
| 简写 | `{ a, b() {} }` | ES2015 | 少写重复代码 | 方法简写有动态 `this` |
| 计算属性名 | `{ [k]: v }` | ES2015 | 动态键 | `k` 为 `undefined` 时会变成字符串 `'undefined'` |
| `for...of` | `for (const v of it)` | ES2015 | 统一遍历 | 普通对象不可迭代 |
| 迭代协议 | `Symbol.iterator` / `next()` | ES2015 | 自定义遍历 | 提前 `break` 会调用 `return()` |
| 生成器 | `function*` / `yield` | ES2015 | 惰性序列、流程控制 | 首次 `next()` 的参数被丢弃 |
| `Symbol` | `Symbol('d')` | ES2015 | 唯一键、语言钩子 | **不是私有属性** |
| `Map` / `Set` | `new Map()` / `new Set()` | ES2015 | 任意键字典 / 去重集合 | 转对象时键会变字符串 |
| `WeakMap` / `WeakSet` | `new WeakMap()` | ES2015 | 不阻止 GC 的关联数据 | 键必须是对象；不可迭代、无 `size` |
| `Proxy` / `Reflect` | `new Proxy(t, traps)` | ES2015 | 拦截对象操作 | 有不变量约束；转发要用 `Reflect` |
| `Object.entries` / `values` | `Object.entries(o)` | ES2017 | 对象 → 数组 | 整数键会排到前面 |
| `Object.fromEntries` | `Object.fromEntries(e)` | ES2019 | 数组 → 对象 | 与 `entries` 互逆 |
| `Object.is` | `Object.is(a, b)` | ES2015 | SameValue 比较 | 与 `===` 只在 `NaN`/`-0` 上不同 |
| 幂运算符 | `a ** b` | ES2016 | 幂运算 | 与 `Math.pow` 等价 |
| `includes` | `arr.includes(x)` | ES2016 | 包含判断 | 能找 `NaN`；对象是引用比较 |
| `async` / `await` | `await p` | ES2017 | 写同步风格的异步 | 串行 `await` 会变慢，用 `Promise.all` |
| `padStart` / `padEnd` | `'7'.padStart(3,'0')` | ES2017 | 对齐与补位 | 超长不截断 |
| 对象展开 | `{ ...o }` | ES2018 | 浅拷贝与合并 | 不复制原型、getter 会求值 |
| 异步迭代 | `for await (const x of it)` | ES2018 | 逐个处理异步数据 | 只能用在 `async` 函数里 |
| `flat` / `flatMap` | `arr.flat(2)` | ES2019 | 展平数组 | 会丢稀疏空洞；`flatMap` 只展平一层 |
| `trimStart` / `trimEnd` | `s.trimStart()` | ES2019 | 去首/尾空白 | 老环境不支持 |
| 可选 `catch` 绑定 | `catch {}` | ES2019 | 不关心错误对象时省掉参数 | 丢失堆栈信息，调试时先别省 |
| 可选链 | `a?.b` | ES2020 | 安全访问 | `a?.b.c` 不保护 `c`；不能赋值 |
| 空值合并 | `a ?? b` | ES2020 | 只兜底 `null`/`undefined` | 不能与 `||`/`&&` 无括号混用 |
| `BigInt` | `10n` | ES2020 | 任意精度整数 | 不能与 `Number` 混算 |
| `Promise.allSettled` | `await Promise.allSettled(ps)` | ES2020 | 等全部结束（含失败） | 结果是 `{status, value/reason}` |
| 动态导入 | `await import('./m.js')` | ES2020 | 按需加载与代码分割 | 变量拼路径会打包整个目录 |
| `globalThis` | `globalThis` | ES2020 | 跨环境的全局对象 | 老环境需 polyfill |
| `replaceAll` | `s.replaceAll('a','b')` | ES2021 | 全部替换 | 正则必须带 `g` |
| `Promise.any` | `await Promise.any(ps)` | ES2021 | 取第一个成功 | 全失败抛 `AggregateError` |
| 逻辑赋值 | `a ??= b` | ES2021 | 缺省赋值 | `a ||= b` 会覆盖 `0`/`''` |
| 数字分隔符 | `1_000_000` | ES2021 | 大数字可读 | 只是书写形式 |
| 顶层 `await` | 模块内 `await` | ES2022 | 模块初始化等待异步 | 只在 ESM 顶层可用 |
| `class` 私有字段 | `#x` | ES2022 | 真正的私有 | 不能在类外访问，反射也拿不到 |
| `Array.prototype.at` | `arr.at(-1)` | ES2022 | 负数索引 | 是方法不是属性：`arr.at` 不加括号拿到的是函数 |
| `Object.hasOwn` | `Object.hasOwn(o,'k')` | ES2022 | 判断自有属性 | 替代 `hasOwnProperty.call` |
| `findLast` | `arr.findLast(f)` | ES2023 | 从后往前找 | 找不到返回 `undefined` |
| 非破坏性数组方法 | `arr.toSorted()` | ES2023 | 不改原数组 | 返回值是新数组，别忽略 |
| `Object.groupBy` | `Object.groupBy(a, f)` | ES2024 | 按规则分组 | 返回值是"无原型对象" |
| `Promise.withResolvers` | `Promise.withResolvers()` | ES2024 | 拿到 `resolve`/`reject` | 记得处理未使用的 Promise |
| 迭代器辅助方法 | `it.map(f).toArray()` | ES2025 | 迭代器上直接链式操作 | 需要较新运行时 |
| `Set` 集合运算 | `a.union(b)` | ES2025 | 交并差 | 同样需要较新运行时 |

> 上表版本归属与可用性**以 MDN 与 TC39 官方最新文档为准**；投产前请确认目标浏览器/Node 版本，或用 `caniuse`、`node.green` 一类兼容性表核对。

---

## 六、注意事项与常见坑

> [!warning] 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（本篇第四节示例就踩过这个坑）。

> [!danger] 三个"看起来能用、实际会崩"的写法
> - **在 `Proxy` 的 `set` 陷阱里写 `obj[prop] = value`**：会再次触发自己的陷阱，造成无限递归（栈溢出）。必须用 `Reflect.set`。
> - **用 `Object.fromEntries` 处理"键可能是 `__proto__`"的数据**：可能污染原型，要显式过滤或用 `Map`。
> - **在 `flat(Infinity)` 之后假设长度不变**：稀疏数组的空洞会被丢弃，索引与长度都可能与预期不符。

> [!tip] 实践建议
> - 现代项目统一用 `const`（需要重新赋值才用 `let`），彻底不用 `var`；
> - 接口数据一律用可选链 + `??` + 解构默认值三件套处理，代码里不出现"防御性 `if` 地狱"；
> - 需要"对象做键"就上 `Map`，需要"给对象挂附加数据且不想泄漏"就上 `WeakMap`；
> - 只读语义优先用非破坏性方法（`toSorted`、`with`、`flatMap`），减少共享可变状态；
> - 新语法上线前，用 `Array.prototype.at`、`groupBy` 这类**较新 API** 时先确认目标运行时版本。

---

## 七、练习题

> [!question] 练习 1（解构与默认值）
> 给定 `const res = { code: 0, data: { user: { name: '', tags: null } } }`，用**一条解构语句**取出 `code`、`name`（缺省为 `'匿名'`）、`tags`（缺省为空数组），并为整个链路提供安全兜底。写出代码并说明为什么 `name` 取到的是 `''` 而不是 `'匿名'`。

> [!question] 练习 2（展开与浅拷贝）
> 写一个函数 `mergeConfig(defaults, userConfig)`，要求：① 不修改任何入参；② 第二层的 `headers` 对象要合并而不是整体替换；③ 用一行代码调用验证。写出实现，并解释为什么单靠 `{ ...defaults, ...userConfig }` 做不到第②点。

> [!question] 练习 3（迭代协议）
> 实现一个 `countdown(n)` 对象：可被 `for...of` 遍历，依次产出 $n, n-1, \dots, 1$；用 `break` 提前退出时要在控制台打印 `已取消`。要求**不使用生成器**，只用手写 `[Symbol.iterator]`。

> [!question] 练习 4（生成器流水线）
> 用生成器实现三个函数：`naturals()` 产出无限自然数、`take(it, n)` 取前 `n` 个、`filter(it, pred)` 过滤。把它们串起来取出"前 5 个偶数"，并说明为什么这个组合不会死循环。

> [!question] 练习 5（Map 与 WeakMap 选型）
> 你要给一批 DOM 节点（或普通对象）缓存"上一次渲染的状态"：① 用 `Map` 实现；② 用 `WeakMap` 实现。然后用 200 字说明：在"节点会被反复创建与删除"的场景下，哪一种会导致内存泄漏、为什么，以及为什么 `WeakMap` 不提供 `size`。

> [!question] 练习 6（Proxy 校验）
> 用 `Proxy` 写一个 `createModel(schema)`：访问未声明字段时抛 `TypeError`，给字段赋错类型时抛 `TypeError`，并保证 `JSON.stringify(model)` 得到的是普通对象结构。写出实现与三个测试用例，说明你为什么在陷阱里用 `Reflect`。

---

## 八、常见问题 FAQ

> [!question] 我需要把 ES6 特性全部学会才能写项目吗？
> 不需要。按"每天都会用"排序，优先级最高的是：`let`/`const`、箭头函数、模板字符串、解构、展开/剩余、可选链与空值合并、`async`/`await`、`Map`/`Set`。**迭代器、生成器、`Proxy`/`Reflect`、`Symbol` 属于"理解了会显著提升上限"的部分**：不写框架时可以不懂，但看不懂 Vue 3 响应式、Redux 中间件、`for await` 的源码就都卡在这里。

> [!question] 用新语法会不会导致老浏览器跑不了？
> 取决于"语法"还是"API"。**语法**（解构、箭头函数、`?.`）可以由 Babel / TypeScript 转译成老语法；**API**（`Map`、`Proxy`、`WeakRef`、`Object.groupBy`）无法转译，只能靠 polyfill（且 `Proxy` 这类根本没法 polyfill），必须按目标环境决定。工程做法是：用 `browserslist` 声明目标范围，让构建工具自动决定转译与 polyfill 策略，详见 [[前端-05-TypeScript]] 与 [[前端-08-构建工具-Vite与Webpack]]。

> [!question] `Map` 和普通对象到底该用哪个？
> 判据是"键的性质"：**键是固定的、已知的字段名**（配置、接口返回的实体）→ 普通对象，`JSON.stringify` 直接可用、写法更短；**键是动态的、可能很多、可能是对象/数字**（缓存、字典、计数器、分组）→ `Map`，它有 `size`、严格插入顺序、任意键类型，且不会与原型上的属性撞名（不必担心 `__proto__`）。

> [!question] `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 官方最新版）](https://tc39.es/ecma262/)
- [TC39 官方流程文档（Stage 0–4 与年度发布）](https://tc39.es/process-document/)
- [Node.js 官方文档（各版本对语言特性的支持情况）](https://nodejs.org/docs/latest/api/)
- [MDN：解构赋值](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment)
- [MDN：展开语法](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Operators/Spread_syntax)
- [MDN：模板字符串](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Template_literals)
- [MDN：箭头函数](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Functions/Arrow_functions)
- [MDN：`let`](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Statements/let) ／ [`const`](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Statements/const)
- [MDN：`Symbol`](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Symbol)
- [MDN：`Symbol.iterator`](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Symbol/iterator)
- [MDN：迭代协议](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Iteration_protocols)
- [MDN：`function*` 生成器](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Statements/function*)
- [MDN：`for...of`](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Statements/for...of)
- [MDN：`Map`](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Map) ／ [`Set`](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Set)
- [MDN：`WeakMap`](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/WeakMap) ／ [`WeakSet`](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/WeakSet)
- [MDN：`Proxy`](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Proxy) ／ [`Reflect`](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Reflect)
- [MDN：`Object.entries()`](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Object/entries) ／ [`Object.fromEntries()`](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Object/fromEntries) ／ [`Object.is()`](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Object/is)
- [MDN：`Array.prototype.includes()`](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Array/includes) ／ [`flat()`](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Array/flat) ／ [`flatMap()`](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Array/flatMap)
- [MDN：`Array.prototype.at()`](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Array/at) ／ [`findLast()`](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Array/findLast)
- [MDN：可选链运算符 `?.`](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Operators/Optional_chaining) ／ [空值合并运算符 `??`](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Operators/Nullish_coalescing)
- [MDN：`String.prototype.replaceAll()`](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/String/replaceAll) ／ [`padStart()`](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/String/padStart)
- [MDN：迭代器辅助方法 `Iterator.prototype.map()`](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Iterator/map)
- [MDN：`Set.prototype.union()`](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Set/union)
- [MDN：`Object.groupBy()`](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Object/groupBy)
- [MDN：`Promise.withResolvers()`](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Promise/withResolvers)
- [现代 JavaScript 教程：解构赋值](https://zh.javascript.info/destructuring-assignment)
- [现代 JavaScript 教程：剩余参数与展开语法](https://zh.javascript.info/rest-parameters-spread)
- [现代 JavaScript 教程：可迭代对象](https://zh.javascript.info/iterable)
- [现代 JavaScript 教程：生成器](https://zh.javascript.info/generators)
- [现代 JavaScript 教程：Map 与 Set](https://zh.javascript.info/map-set)
- [现代 JavaScript 教程：WeakMap 与 WeakSet](https://zh.javascript.info/weakmap-weakset)
- [现代 JavaScript 教程：Proxy 与 Reflect](https://zh.javascript.info/proxy)
- [现代 JavaScript 教程：Symbol 类型](https://zh.javascript.info/symbol)
- [现代 JavaScript 教程：可选链](https://zh.javascript.info/optional-chaining)
- [现代 JavaScript 教程：空值合并运算符](https://zh.javascript.info/nullish-coalescing-operator)
- 说明：**各特性的版本归属、Stage 阶段、目标环境可用性都属于版本敏感信息，以 MDN 与 TC39 官方最新文档为准。** 本篇代码除特别标注外均在本机 Node.js v24.18.0 上实测通过。
