JavaScript 学习宝典
CHAPTER 01 · 语言基础

认识 JavaScript 与运行方式

一句话总览:JS 是一门单线程、动态类型、事件驱动的语言——同一时刻只干一件事,靠「事件循环」把等待的活儿排进队列,而不是开新线程。
🍜
生活化类比
JS 引擎像一家只有一个厨师的面馆:厨师(主线程)一次只炒一份菜(执行一段代码)。遇到「炖汤要 40 分钟」(网络请求/定时器),他不会站着等,而是把汤交给后厨设备(浏览器 Web API / Node 底层),贴张单子继续炒下一份;汤好了,单子进「出餐队列」,厨师炒完手头的菜再来处理。边界:真实面馆可以多雇厨师,而 JS 主线程永远只有一个——所以一段死循环代码会「卡死整个页面」,这是类比失效的地方,也是理解 JS 的关键。

1.1 代码在哪里跑:引擎 + 宿主

JS 语言本身只定义了语法和内置对象;document、fetch、setTimeout 都是宿主环境(浏览器 / Node.js)额外提供的能力。同一门语言,换个宿主就换一套 API。

层浏览器Node.js负责什么
JS 引擎V8(Chrome)/ SpiderMonkey(Firefox)V8解析、编译、执行 JS,管理内存
宿主 APIDOM、fetch、定时器fs、http、process文件、网络、系统等「语言之外」的能力
事件循环浏览器实现(含渲染时机)libuv 实现(分阶段)调度异步回调的执行顺序

1.2 加载脚本:为什么推荐 defer

index.html
<script src="a.js"></script>         <!-- 阻塞 HTML 解析,下载+执行完才继续 -->
<script defer src="b.js"></script>   <!-- 并行下载,HTML 解析完后按顺序执行 ✓ -->
<script async src="c.js"></script>   <!-- 并行下载,下载完立刻执行,顺序不保证 -->
⚠ 高频陷阱:脚本放 head 里不加 defer
脚本立即下载执行,此时 document.querySelector('#app') 拿到的元素还没被解析出来,返回 null,后续 .addEventListener 直接抛 TypeError。正确姿势:业务脚本一律 defer;只有互不依赖的统计/广告脚本才用 async。
✓ 记忆口诀
「defer 排队等开饭,async 做好就上桌」——defer 保序、等 DOM;async 抢跑、不保序。

1.3 随堂自测

QUIZ 1
页面里一段 while(true){} 死循环会导致什么?
JS 主线程只有一个,渲染和事件回调也要靠它执行。死循环霸占主线程,事件循环永远转不到下一圈,页面整体冻结。JS 没有「自动超时中断」机制。
QUIZ 2
两个有依赖关系的脚本(b.js 依赖 a.js 的变量),应该怎么加载?
defer 保证「HTML 解析完后按书写顺序执行」,天然满足依赖关系。async 谁先下完谁先跑,b 可能先于 a 执行而报错;浏览器不会分析脚本依赖。
CHAPTER 02 · 语言基础

变量与数据类型

一句话总览:默认用 const,要重新赋值才用 let,永远别用 var;JS 有 7 种原始类型 + 对象,原始值存「值本身」,对象存「引用」——这条分界线决定了后面无数行为。
🏷️
生活化类比
变量是贴在东西上的标签。原始类型像一张写着数字的便利贴:复印一张给别人(赋值),两张互不影响。对象像一把仓库钥匙:赋值只是配了把一样的钥匙,两个人开的是同一间仓库,谁搬东西对方都看得到。const 的意思是「标签不许撕下来重贴」(不能重新赋值),但仓库里的东西照样能搬(对象属性可改)——这是类比里最容易被忽略的一格。

2.1 let / const / var 三兄弟

特性varletconst
作用域函数作用域块级 {}块级 {}
声明前使用得到 undefined(提升)报错(TDZ)报错(TDZ)
重复声明允许(静默覆盖)报错报错
重新赋值允许允许禁止(但对象内部可改)
variables.js
console.log(a);   // undefined —— var 声明被提升,值还没赋
var a = 1;

console.log(b);   // ❌ ReferenceError!let 也有提升,但处于"暂时性死区"
let b = 2;

const user = { name: '润曦' };
user.name = '肖俊';   // ✓ 合法:改的是仓库里的货,不是换钥匙
user = {};            // ❌ TypeError:const 禁止重新赋值
⚠ 高频陷阱:var 的循环变量共享
for (var i = 0; i < 3; i++) { setTimeout(() => console.log(i)) } 输出 3 3 3——三个回调共享同一个函数级 i,循环结束时 i 已是 3。改成 let,每轮迭代生成一个独立的 i,输出 0 1 2。这是闭包章的经典伏笔。

2.2 八种类型与 typeof

类型版图:7 种原始类型 + 1 种对象
原始类型(存值本身,不可变) number 42 / 3.14 string '你好' boolean true undefined null symbol bigint 9007…n undefined=没赋值;null=故意置空 对象类型(存引用) Object { } Array [ ] Function Date / Map / Set… 赋值 = 复制钥匙
typeof null === 'object' 是历史 bug;判断数组用 Array.isArray,别用 typeof。
typeof.js
typeof 42          // 'number'
typeof 'hi'        // 'string'
typeof undefined   // 'undefined'
typeof null        // 'object'  ⚠ 历史遗留 bug,记住就行
typeof []          // 'object'  ⚠ 分不清数组!
Array.isArray([])  // true ✓ 判断数组的正确姿势
typeof (() => {})  // 'function'
✓ 记忆口诀
「const 优先,let 兜底,var 入土;原始传值,对象传钥匙。」

2.3 随堂自测

QUIZ 1
const arr = [1, 2]; arr.push(3); 会发生什么?
const 锁的是「变量与引用之间的绑定」,不是对象内容。push 改的是数组本身,完全合法;只有 arr = [...] 这种重新赋值才会报错。想冻结内容要用 Object.freeze。
QUIZ 2
在 let x = 1; 这一行之前执行 console.log(x),结果是?
let/const 的声明同样被提升,但从块开始到声明语句之间是 TDZ(暂时性死区),访问直接抛 ReferenceError。var 才是「提升且初始化为 undefined」。
CHAPTER 03 · 语言基础

运算符与类型转换

一句话总览:判等永远用 ===;|| 会把 0、''、false 当「没有」,想只排除 null/undefined 请用 ??——JS 大多数「玄学 bug」都出在隐式转换上。
🛂
生活化类比
== 像宽松的门卫:拿着字符串 '5' 来,他说「换算一下不就是数字 5 嘛,进!」(先隐式转换再比较)。=== 是严格的门卫:证件号和证件类型都得一致,'5' 和 5 直接拒之门外。宽松门卫的规则表极其复杂(null、NaN、对象各有特例),你记不全,bug 就来了——所以现实工程里干脆只用严格门卫。

3.1 假值名单与短路运算

JS 里只有 8 个假值:false、0、-0、0n、''、null、undefined、NaN。其余全是真值——包括 '0'、'false'、[]、{}!

coerce.js
'5' == 5     // true  ⚠ 字符串被转成数字再比
null == undefined  // true(仅此一对特例)
NaN == NaN   // false!NaN 谁都不等,包括自己
[] == false  // true ⚠ 玄学链条:[] → '' → 0 → false

0.1 + 0.2 === 0.3            // false!二进制浮点存不下 0.1
Math.abs(0.1 + 0.2 - 0.3) < 1e-9   // true ✓ 用误差范围比较

const count = 0;
count || 10   // 10 ⚠ 0 被当成"没有",默认值逻辑出错
count ?? 10   // 0  ✓ ?? 只排除 null / undefined
⚠ 高频陷阱:用 || 设默认值
function page(n) { n = n || 1 }——用户传 0(第 0 页)会被静默改成 1,产生不报错但结果错的业务 bug。正确姿势:n ?? 1 或函数默认参数 function page(n = 1)(默认参数同样只对 undefined 生效)。

3.2 == 与 === 决策图

'5' 和 5 比较:两条完全不同的路
'5' ? 5 == 宽松相等 类型不同 → 先隐式转换:'5' → 5 结果 true(规则复杂易踩坑) === 严格相等 类型不同 → 直接 false,不转换 结果 false(可预测 ✓)
=== 的心智模型只有一句话:类型不同直接 false。可预测性就是它的全部价值。
✓ 记忆口诀
「判等三等号,默认双问号;假值八个背下来,空串空数组是真值。」

3.3 随堂自测

QUIZ 1
下列哪个表达式的结果是 true?
'0' 是非空字符串,是真值。NaN 不等于任何值;0.1+0.2 是 0.30000000000000004;null 和 undefined 只有 == 才相等,=== 类型不同直接 false。判断 NaN 用 Number.isNaN。
QUIZ 2
表单里用户填了数量 0,代码 const n = input || 5; 得到什么?
|| 返回第一个真值:0 是假值,所以取右边的 5,用户的真实输入被静默丢弃。改成 input ?? 5 即可——?? 只在 null/undefined 时才取默认值。
CHAPTER 04 · 语言基础

函数与箭头函数

一句话总览:函数在 JS 里是一等公民——能存变量、当参数、当返回值;箭头函数不只是写法短,它没有自己的 this 和 arguments,这才是本质区别。
🎫
生活化类比
普通函数像实名制的工牌:谁调用它,工牌上就临时写谁的名字(this 由调用方式决定)。箭头函数像出生时就刻好名字的传家宝:this 在定义那一刻就继承外层,之后无论谁调用都改不了。边界:工牌可以借给别人戴(call/apply 改 this),传家宝借出去名字也不变——所以对象方法、构造函数别用箭头函数。

4.1 三种定义方式与提升差异

functions.js
say();                       // ✓ 函数声明整体提升,可提前调用
function say() { console.log('hi'); }

greet();                     // ❌ TypeError: greet is not a function
var greet = function() {};   // 变量提升但值还是 undefined

const add = (a, b) => a + b;           // 箭头函数:单表达式隐式 return
const square = x => x * x;             // 单参数可省括号
const makeUser = name => ({ name });   // ⚠ 返回对象字面量必须套 ()

function total(base, tax = 0.1, ...extra) {  // 默认参数 + rest 收集
  return base * (1 + tax) + extra.reduce((s, n) => s + n, 0);
}
total(100, 0.1, 5, 5);   // 120
⚠ 高频陷阱:箭头函数返回对象
const f = () => { name: 'x' } 返回 undefined——花括号被解析成函数体,name: 成了标签语句。正确姿势:() => ({ name: 'x' }),用小括号包住对象字面量。

4.2 箭头函数 vs 普通函数

能力普通函数箭头函数
this调用时动态绑定定义时继承外层,call/apply 也改不了
arguments 对象有没有(用 rest 参数代替)
new 构造可以❌ 直接 TypeError
prototype 属性有没有
适合场景对象方法、构造函数、需要动态 this回调、数组方法、保持外层 this
this-preview.js
const timer = {
  seconds: 0,
  startBad() {
    setInterval(function() { this.seconds++; }, 1000);  // ⚠ this 指向全局/undefined
  },
  startGood() {
    setInterval(() => { this.seconds++; }, 1000);       // ✓ 箭头继承 startGood 的 this
  }
};
✓ 记忆口诀
「回调箭头最省心,方法构造用 function」——箭头的 this 是出生定的,普通函数的 this 是现场定的。

4.3 随堂自测

QUIZ 1
const f = () => { count: 1 }; f() 的返回值是?
{} 被当成函数体,count: 是合法的标签语句,1 是孤立表达式,函数没有 return 所以返回 undefined。语法完全合法,错得悄无声息——要返回对象需写成 () => ({ count: 1 })。
QUIZ 2
对象方法里用 setTimeout(function(){ this.x++ }, 100),this.x 为什么改不到对象上?
普通函数的 this 看「怎么被调用」:定时器回调由引擎直接调用,非严格模式指向全局对象,严格模式是 undefined。换箭头函数继承外层 this,或提前 const self = this。
CHAPTER 05 · 核心机制

对象与引用:拷贝的水有多深

一句话总览:对象变量存的是指向堆内存的引用;... 和 Object.assign 只拷一层(浅拷贝),嵌套对象仍然共享——想彻底断开用 structuredClone。
🗄️
生活化类比
浅拷贝像复印一份文件柜的目录:新目录(外层对象)是你的了,但目录里「三号抽屉」那一栏指向的还是原来那个抽屉(嵌套对象)。你往三号抽屉放东西,原柜子的主人打开一看——东西也在!深拷贝则是把每个抽屉连同内容全部复制一套。边界:structuredClone 连循环引用都能拷,但函数、DOM 节点拷不了——「文件」能复制,「活人」(函数)复制不了。

5.1 引用到底长什么样

浅拷贝后:外层是两份,内层还是一份
栈(变量) 堆(对象数据) a(原对象) b = { ...a } { name:'JS', info: → } { name:'JS', info: → } { ver: 6 } 共享的嵌套对象 b.info.ver = 7 会同时改掉 a.info.ver!
展开运算符只复制「第一层属性的值」;属性值若是引用,复制的是引用本身。
copy.js
const a = { name: 'JS', info: { ver: 6 } };
const b = { ...a };          // 浅拷贝
b.name = 'TS';               // ✓ a.name 不受影响(第一层断开了)
b.info.ver = 7;              // ⚠ a.info.ver 也变成 7!

const c = structuredClone(a);  // ✓ 深拷贝,嵌套也彻底断开
c.info.ver = 99;               // a.info.ver 仍是 7

const d = JSON.parse(JSON.stringify(a));  // 老式深拷贝
// ⚠ 会丢掉 undefined/函数/Symbol,Date 变字符串,循环引用直接抛错
⚠ 高频陷阱:React/状态更新里的浅拷贝
只 { ...state } 就修改 state.user.age,旧状态被一起污染,导致「回滚失效 / 渲染不更新」这类静默错误。正确姿势:沿修改路径逐层展开,或直接 structuredClone(注意它不能拷函数)。

5.2 拷贝方案速查

方案深度局限适用
{ ...obj } / Object.assign一层嵌套共享扁平对象、合并配置
JSON.parse(JSON.stringify())深丢函数/undefined,Date 失真,怕循环引用纯 JSON 数据
structuredClone()深不能拷函数/DOM现代浏览器/Node 17+ 首选
✓ 记忆口诀
「展开只剥一层皮,深拷就找 structuredClone。」

5.3 随堂自测

QUIZ 1
const a = { x: { n: 1 } }; const b = { ...a }; b.x.n = 2; 此时 a.x.n 是?
... 只复制第一层:b.x 复制的是 a.x 里存的引用,两个 x 指向堆里同一个对象。改 b.x.n 等于改 a.x.n。要断开需 structuredClone 或逐层展开。
QUIZ 2
用 JSON.parse(JSON.stringify(obj)) 深拷贝,下列哪种数据会出问题?
JSON 序列化只认 JSON 类型:函数/undefined/Symbol 被静默丢弃,Date 转成 ISO 字符串后 parse 不回来,循环引用直接抛 TypeError。纯 JSON 数据才能安全走这条路。
CHAPTER 06 · 核心机制

数组与函数式方法

一句话总览:把数组方法分成「改原数组」和「返回新数组」两派是第一课;map/filter/reduce 三板斧能替代 90% 的手写 for 循环,而且意图更清晰。
🍡
生活化类比
数组是一串糖葫芦。map 是「每颗山楂换成草莓」——给你一串新的;filter 是「把坏的挑掉」——剩下一串新的;reduce 是「全部熬成一锅酱」——多进一出。而 push / splice / sort 是直接在原来那串上动手。边界:forEach 看着像 map,但它只是「挨个看一眼」,返回值永远是 undefined——别拿它当 map 用。

6.1 两大阵营:先分清谁动原数组

阵营方法返回值
改原数组(危险区)push pop shift unshift splice sort reverse fill被删元素 / 原数组本身
返回新数组(安全区)map filter slice concat flat toSorted toSpliced新数组,原数组不动
只读遍历forEach find findIndex some every includes indexOfundefined / 元素 / 布尔 / 下标
多进一出reduce join任意累积值 / 字符串
arrays.js
const nums = [3, 1, 4, 1, 5];

nums.map(n => n * 2)          // [6,2,8,2,10] 新数组
nums.filter(n => n > 2)       // [3,4,5]
nums.reduce((sum, n) => sum + n, 0)   // 14 ← 0 是初始值,别省!
nums.find(n => n > 3)         // 4(第一个满足的)
nums.some(n => n > 4)         // true

nums.sort()                   // ⚠ 原数组被改!且默认按"字符串"排
[10, 9, 1].sort()             // [1,10,9] ⚠ '10' < '9'
[10, 9, 1].sort((a, b) => a - b)   // [1,9,10] ✓ 数字比较器
[10, 9, 1].toSorted((a, b) => a - b)  // ✓ 新数组版,原数组不动
⚠ 高频陷阱:sort 的字典序
[10, 9, 1].sort() 得到 [1, 10, 9]——默认把元素转字符串按 UTF-16 逐位比较。数字排序必须传比较器 (a, b) => a - b;同时记住 sort 会改原数组,props/state 里的数组直接 sort 是事故高发区,用 toSorted 或先 [...arr]。

6.2 reduce:把数组「折叠」成一个值

reduce((sum, n) => sum + n, 0) 的折叠过程
acc=0 +3 → 3 +1 → 4 +4 → 8 +1 → 9 +5 → 14 每一步:acc = 回调(acc, 当前元素),结果作为下一步的 acc 不传初始值时,acc 取第一个元素、从第二个开始遍历——空数组直接抛 TypeError! acc 也可以是对象/数组:分组、去重、构建 Map 都靠它。
reduce 的本质是「带着累积值走一遍数组」,初始值决定累积值的类型,永远显式传。
✓ 记忆口诀
「map 变形,filter 筛选,reduce 归一;push/splice/sort 动原件,map/filter/slice 出新品。」

6.3 随堂自测

QUIZ 1
[10, 9, 1].sort() 的结果是?
默认按字符串字典序:'1' < '10' < '9'(逐字符比较,'1'开头都排在'9'前)。要按数值排必须传 (a,b)=>a-b。不报错、结果错,才最危险。
QUIZ 2
const r = [1,2,3].forEach(n => n * 2); r 的值是?
forEach 永远返回 undefined,回调的返回值被丢弃——它只负责「遍历执行副作用」。要收集变形结果用 map;要累积成一个值用 reduce。
CHAPTER 07 · 核心机制

作用域与闭包

一句话总览:作用域在写代码时就定死(词法作用域);闭包 = 函数 + 它出生时所在环境的变量——外层函数返回后,那些变量依然活着,只被这个函数私有访问。
🎒
生活化类比
函数出厂时背着一个背包,里面装着它定义处能看到的变量(外层作用域)。之后它被传到哪里执行都不重要——查变量先翻自己的口袋(局部),再翻背包(外层),一层层翻到全局,这条链就是作用域链。外层函数执行完,「厂房」拆了,但背包还被函数背着,里面的变量就拆不掉——这就是闭包。边界:背包里装的是变量本身而不是快照,变量后来变了,函数看到的也是新值(var 循环陷阱的根源)。

7.1 词法作用域:看出生地,不看执行地

lexical.js
const x = 'global';
function outer() {
  const x = 'outer';
  function inner() { console.log(x); }  // 查变量沿"定义处"的链
  return inner;
}
function run(fn) {
  const x = 'run';    // ⚠ 这个 x 对 fn 完全不可见
  fn();
}
run(outer());   // 'outer' —— 不是 'run' 也不是 'global'!

7.2 闭包:变量的「私有保险箱」

closure.js
function makeCounter() {
  let count = 0;               // 被 inner 引用的变量不会随返回而销毁
  return () => ++count;
}
const c1 = makeCounter();
c1(); c1();                    // 2
const c2 = makeCounter();
c2();                          // 1 —— 每次调用 makeCounter 都是新背包
// 外部没有任何办法直接摸到 count —— 天然的私有变量
闭包的内存视角:栈帧没了,被引用的变量还活在堆里
makeCounter 的栈帧 执行完毕,已弹出销毁 (虚线 = 已不存在) c1(箭头函数) 背着作用域背包 count = 2 被引用 → 留在堆中 c2(另一次调用) 独立的新背包 count = 1 与上面互不相干
垃圾回收只清「没人引用」的东西:闭包引用着 count,count 就一直活着——这既是能力也是泄漏源。
⚠ 高频陷阱:循环 + var + 异步回调
for (var i = 0; i < 3; i++) setTimeout(() => console.log(i)) 打印 3 3 3:三个闭包背的是同一个 i。改 let(每轮新建绑定)或 setTimeout(console.log, 0, i)(按值传参)都能修。另外,闭包挂着大对象又长期不释放(全局缓存、忘了移除的监听器),就是典型内存泄漏。
✓ 记忆口诀
「作用域看出生地,闭包是随身背包;包里的变量别人摸不到,也扔不掉。」

7.3 随堂自测

QUIZ 1
词法作用域下,函数查找变量的依据是?
JS 是词法(静态)作用域:作用域链在书写代码时就确定,与调用位置无关。所以把函数传到别处执行,它看到的仍是出生地的变量。this 才看调用方式——别把两者混了。
QUIZ 2
makeCounter 返回的 c1 调了 2 次后,再执行 const c2 = makeCounter(); c2();,c2 返回?
闭包捕获的是「那一次函数调用的环境」:每次执行 makeCounter 都新建一个 count=0 的环境,c1 和 c2 各背各的背包,互不影响。若 count 定义在 makeCounter 外面,才会共享。
CHAPTER 08 · 核心机制

this 与原型链

一句话总览:this 不看你写在哪,只看函数怎么被调用(new > bind > obj.fn() > 裸调用);对象找不到属性时,沿着 __proto__ 原型链一层层向上找,直到 null。
🏠
生活化类比
原型链像族谱借东西:你要一把螺丝刀(属性),先翻自己家抽屉;没有就去爸爸家(__proto__)找,再没有去爷爷家……直到族谱尽头(null)还找不到,才返回 undefined。class extends 只是给这条「认亲链」换了个优雅写法。边界:借来的方法里如果用了 this,this 仍指向「发起借用的你」,不是族谱上的长辈——方法共享,this 不共享。

8.1 this 绑定四规则(优先级从高到低)

优先级调用形式this 指向
1new Fn()新创建的对象
2fn.call(obj) / fn.bind(obj)()指定的 obj
3obj.fn()点号前面的 obj
4fn() 裸调用严格模式 undefined;非严格全局对象
例外箭头函数不参与以上规则,继承定义处外层 this
this.js
const user = {
  name: '润曦',
  hello() { return 'hi ' + this.name; }
};
user.hello();              // 'hi 润曦' —— 规则3:点号前是 user

const fn = user.hello;     // ⚠ 把函数"摘"下来,脱离了 user
fn();                      // 'hi undefined' —— 规则4:裸调用!

const bound = user.hello.bind(user);
bound();                   // 'hi 润曦' ✓ bind 钉死 this
// 经典事故:btn.addEventListener('click', user.hello)
// 回调被裸调用 → this 不是 user,要 bind 或包一层箭头
⚠ 高频陷阱:方法被「摘下来」传递
const fn = obj.method; fn()、把方法直接当事件回调/数组回调传——都会丢失 this,读到 undefined 的属性再抛 TypeError。正确姿势:bind、箭头包装 () => obj.method(),或方法本身写成箭头(但注意对象字面量里的箭头 this 不指向该对象)。

8.2 原型链查找路径

arr.push 是怎么被找到的:三级原型链
arr = [1,2] 自身只有 0、1、length Array.prototype push / map / filter… Object.prototype toString / hasOwnProperty null __proto__ __proto__ __proto__ arr.push(3) 的查找:自身没有 → Array.prototype 命中 ✓(到此为止) arr.foo 的查找:自身 → Array → Object → null,返回 undefined 方法只存一份在 prototype 上,所有实例共享——这就是 JS 省内存的继承方式。
class 的 extends 本质就是把构造函数的 prototype 挂到父类 prototype 上,语法糖底下还是这条链。
class.js
class Animal {
  constructor(name) { this.name = name; }
  speak() { return this.name + ' makes a sound'; }  // 挂在 Animal.prototype
}
class Dog extends Animal {
  speak() { return this.name + ' barks'; }   // 自身原型上覆盖(遮蔽)
}
const d = new Dog('旺财');
d.speak();                       // '旺财 barks'
d instanceof Animal              // true —— 沿原型链能找到 Animal.prototype
✓ 记忆口诀
「this 看调用:new、bind、点号、裸;属性看族谱:自己、爸爸、爷爷、null。」

8.3 随堂自测

QUIZ 1
btn.addEventListener('click', user.sayName)(sayName 是普通方法,内部用 this.name),点击时 this 指向?
addEventListener 会把回调的 this 设为绑定事件的元素。方法被「摘下来」后与 user 再无关系。修法:bind(user) 或 () => user.sayName()。这题同时考「this 看调用」和「方法脱离对象」两个机制。
QUIZ 2
读取 obj.x 时 obj 自身没有 x,引擎会?
属性访问走原型链(对象之间的委托关系),与作用域链(变量查找)是两套完全独立的机制。读不到属性返回 undefined 不报错;访问不存在的「变量」才抛 ReferenceError。
CHAPTER 09 · 异步与事件循环

事件循环:异步代码的总调度

一句话总览:同步代码在调用栈里一口气跑完 → 清空全部微任务(Promise.then 等)→ 取一个宏任务(setTimeout 等)→ 再清空微任务……如此循环,这就是所有输出顺序题的唯一裁判。
🍽️
生活化类比
厨师(主线程)炒菜规则:① 手头的菜炒完(清空调用栈);② 先看加急单(微任务队列),有多少做多少,一张不剩;③ 再从普通单(宏任务队列)里只取一张做;④ 做完又回到②。加急单永远插队,且会「做到没有为止」——所以疯狂产生微任务会让普通单和上菜(页面渲染)永远轮不上。边界:真实厨房加急单再多也会累,JS 是真的会无限清微任务直到饿死渲染。

9.1 谁进哪个队列

类别常见成员调度时机
同步代码普通语句、函数调用立即,在调用栈中执行
微任务Promise.then/catch/finally、queueMicrotask、await 之后的代码、MutationObserver栈一空就全部清空(含执行中新产生的)
宏任务setTimeout / setInterval、I/O、事件回调、script 整体每轮只取一个
渲染样式计算、绘制宏任务之间由浏览器择机插入(不是每轮都有)
order.js —— 面试必考输出题
console.log('A');                          // 同步
setTimeout(() => console.log('B'), 0);     // 宏任务
Promise.resolve().then(() => console.log('C'));  // 微任务
console.log('D');                          // 同步
// 输出:A → D → C → B
// 同步 A、D 先跑;栈空清微任务 C;下一轮宏任务才轮到 B

9.2 动手演示:一步步看队列怎么转

HANDS-ON DEMO
事件循环模拟器
场景就是上面那段 order.js。点「下一步」,观察调用栈、微任务队列、宏任务队列与输出的变化——亲眼验证 A D C B。
⚠ 高频陷阱:setTimeout(fn, 0) 不是「立刻」
0 毫秒只是「尽快排队」,实际要等当前同步代码 + 全部微任务跑完,且嵌套超过 5 层浏览器会强制最小 4ms。想「栈空后马上执行」用 queueMicrotask;想「下一帧渲染前」用 requestAnimationFrame。另外,递归 Promise.then 产生微任务会饿死宏任务和渲染,页面直接假死——递归调度请用 setTimeout。
✓ 记忆口诀
「同步跑到底,微任务清到空,宏任务一轮拿一个。」

9.3 随堂自测

QUIZ 1
同步代码执行完,微任务队列里有 3 个回调,宏任务队列里有 2 个,接下来?
微任务的规则是「清空为止」,包括执行过程中新加入的;宏任务每轮只取一个。两个队列不是平等的 FIFO 关系,微任务拥有绝对插队权。
QUIZ 2
下列哪个属于微任务?
Promise 回调、queueMicrotask、await 后续代码都是微任务;定时器、I/O、DOM 事件回调都是宏任务。「延迟 0」不改变任务的类别,只影响入队时间。
CHAPTER 10 · 异步与事件循环

Promise:异步结果的「期票」

一句话总览:Promise 是一张状态不可逆的期票:pending → fulfilled 或 rejected,落定即冻结;then 返回新 Promise,链式调用与错误沿着链一路向下传,直到被 catch 接住。
🧾
生活化类比
点外卖拿到一张取餐小票(Promise):此刻餐还在做(pending)。小票最终只会盖一个章:「已出餐」(fulfilled,附赠餐品=value)或「已取消」(rejected,附原因=error),盖了章就不能改——商家再喊一百次「出餐了」也没用(重复 resolve 被忽略)。你可以提前在小票上登记「出餐后帮我送到 X」(then),也可以餐好了再登记——登记的动作永远有效,只是执行时机不同。边界:小票可以复印无数张(同一个 Promise 挂多个 then),每张登记都会各自收到通知。

10.1 状态机与链式规则

chain.js
fetch('/api/user')                 // 返回 Promise<Response>
  .then(res => res.json())         // ✓ return 新 Promise → 下一环等它落定
  .then(user => {
    console.log(user.name);        // ⚠ 这里忘了 return
  })
  .then(x => console.log(x))       // undefined!链上传的是上一环的返回值
  .catch(err => console.error(err))  // 上游任何一环 reject 都跳到这里
  .finally(() => hideLoading());     // 成败都执行,适合收尾
⚠ 高频陷阱:then 里忘写 return
链式调用中每一环的输出 = 回调的返回值。忘了 return,下一环拿到 undefined,后续 undefined.xxx 抛错——错误还发生在「看起来无关」的下游,极难定位。同理:then 里 return fetch(...) 才会等待嵌套请求;不 return 就是「发射后不管」,catch 也接不到它的错误。

10.2 动手演示:Promise 状态机

HANDS-ON DEMO
Promise 状态机模拟器
先注册 .then/.catch 再落定,和先落定再注册,效果一样但时机不同;落定后再 resolve/reject 会被无视。点按钮试试各种顺序。

10.3 组合器:并发多张期票

API成功条件失败行为典型场景
Promise.all全部成功任一失败立即整体 reject(短路)页面依赖的多个接口
Promise.allSettled永远成功逐个给出 status/value/reason批量任务,允许部分失败
Promise.race第一个落定的(无论成败)第一个是失败就失败超时控制
Promise.any第一个成功的全失败才 reject(AggregateError)多源取最快可用
✓ 记忆口诀
「状态一锤定音,then 环环相扣;忘了 return 断链条,错误下沉 catch 兜。」

10.4 随堂自测

QUIZ 1
一个 Promise 先 resolve(1) 再 reject('err'),最终状态是?
Promise 状态只能从 pending 变一次,落定即冻结。第二次 settle 调用不报错、不生效——所以「resolve 之后的代码」仍会执行,但改变不了结果,必要时记得 return 提前退出。
QUIZ 2
Promise.all([p1, p2, p3]) 中 p2 失败、p1 p3 成功,结果是?
all 是「全成才成,一败即败」的短路语义。想拿到每个任务的独立结局用 allSettled;想要第一个成功的用 any。注意:reject 后其余任务并不会被取消,只是结果被忽略。
CHAPTER 11 · 异步与事件循环

async/await:把异步写成「人话」

一句话总览:async/await 是 Promise 的语法糖:await 把「then 之后的代码」暂停成微任务续体,不阻塞主线程;串行 await 慢,独立请求要先同时发起再一起 await。
🧺
生活化类比
洗衣服(请求 A,30 分钟)和烧水(请求 B,10 分钟)。串行 await 是「守着洗衣机洗完,才去按下烧水壶」——共 40 分钟;并发是「两个开关都按下,该干嘛干嘛,都好了再收」——共 30 分钟。await 不是站在原地等,它更像定了个闹钟:函数暂停,主线程去忙别的,结果好了再回来继续。边界:如果 B 需要 A 的结果(先洗完才能晾),那只能串行——依赖关系决定能不能并发。

11.1 基本语法与错误处理

async.js
async function loadUser() {          // async 函数永远返回 Promise
  try {
    const res = await fetch('/api/user');   // 暂停本函数,不卡主线程
    if (!res.ok) throw new Error('HTTP ' + res.status);  // fetch 只对网络错误 reject!
    const user = await res.json();
    return user;                     // 等价于 resolve(user)
  } catch (err) {
    console.error('加载失败:', err);  // 接住链上任何 await 的 reject
    return null;                     // 兜底值,调用方拿到的仍是 resolved
  }
}
⚠ fetch 的 404/500 不算失败
fetch 只在网络层失败(断网、DNS 错)才 reject;HTTP 404/500 依然 resolve,只是 res.ok === false。不检查 res.ok 会把错误页当正常数据解析,产生静默业务 bug——上面第 4 行就是标准姿势。

11.2 串行 vs 并发:时间轴一眼看懂

两个独立请求:串行 40 分钟 vs 并发 30 分钟
串行:await A 之后才发起 B await fetchA() 30min await fetchB() 10 总计 40min 并发:先发起,再一起等 fetchA() 30min fetchB() 10 Promise.all 等最慢的一个 → 30min const [a, b] = await Promise.all([pa, pb])
并发省的是「等待重叠」的时间:请求发起后就在后台跑,await 只是决定你什么时候收结果。
parallel.js
// ❌ 串行:两个独立请求白白多等
const a = await fetchA();
const b = await fetchB();

// ✓ 并发:先拿到两张"期票",再一起等
const pa = fetchA(), pb = fetchB();      // 此刻两个请求已同时出发
const [a2, b2] = await Promise.all([pa, pb]);

// ❌ forEach 不认 async:回调的 Promise 被无视,循环"瞬间跑完"
list.forEach(async item => { await save(item); });
console.log('done');   // ⚠ 先打印!保存还在后台进行
// ✓ 要逐个串行用 for...of;要并发用 map + Promise.all
await Promise.all(list.map(item => save(item)));
⚠ 高频陷阱:forEach + async
forEach 不会等待回调返回的 Promise,「全部保存完成」之后的代码提前执行,出现数据没存完就跳转/刷新的事故。串行用 for...of + await,并发用 Promise.all(list.map(...))。
✓ 记忆口诀
「await 只停自己的函数,不停整个世界;无依赖就并发,有依赖才串行。」

11.3 随堂自测

QUIZ 1
async 函数里执行 await fetch(url) 期间,主线程在干什么?
await 只暂停当前 async 函数(把续体挂到 Promise 上),主线程继续处理渲染和其他事件。网络下载由浏览器底层完成,不占 JS 线程。这正是「单线程却不卡」的关键。
QUIZ 2
三个互不依赖的接口各需 1s,用 const [a,b,c] = await Promise.all([f1(),f2(),f3()]) 总耗时约?
f1() f2() f3() 在构造数组时就已全部发起,Promise.all 只是等它们都落定,总耗时 ≈ 最慢的那个。写成三个连续 await 才是 3s。顺序不影响并发。
CHAPTER 12 · 异步与事件循环

迭代器与生成器

一句话总览:能被 for...of 和 ... 消费的对象,都实现了 Symbol.iterator 协议;生成器(function* + yield)是能暂停的函数,天生就是迭代器,按需吐值、惰性求值。
🎰
生活化类比
普通数组像整箱矿泉水:一次搬回家,占地方。生成器像自动售货机:你按一次按钮(next()),它吐一瓶({ value, done }),不按就不生产——要一百万瓶也不用先造一百万瓶(惰性)。for...of 就是「不停按按钮直到出空签(done: true)」的自动手。边界:售货机吐过的瓶子收不回来——生成器是一次性的,遍历完就 exhausted,想再来一遍得重新调用生成器函数。

12.1 迭代协议:for...of 背后的合同

iterator.js
const arr = ['a', 'b'];
const it = arr[Symbol.iterator]();   // 拿到迭代器
it.next();   // { value: 'a', done: false }
it.next();   // { value: 'b', done: false }
it.next();   // { value: undefined, done: true }

// 给普通对象装上迭代器,它就能被 for...of / ... 消费
const range = {
  from: 1, to: 3,
  [Symbol.iterator]() {
    let cur = this.from, last = this.to;
    return { next: () => cur <= last
      ? { value: cur++, done: false }
      : { value: undefined, done: true } };
  }
};
[...range];   // [1, 2, 3] ✓ 展开、解构、for...of 全部解锁

12.2 生成器:会暂停的函数

generator.js
function* idMaker() {
  let id = 1;
  while (true) {          // 无限循环也不怕:每次 next 才走一步
    yield id++;           // 暂停点:吐出值,冻结现场,等下次 next
  }
}
const ids = idMaker();    // ⚠ 此刻函数体一行都没执行!
ids.next().value;         // 1 —— 跑到第一个 yield 停下
ids.next().value;         // 2 —— 从上次暂停处继续

function* take3() { yield 1; yield 2; yield 3; }
[...take3()];             // [1,2,3] 生成器自带迭代器协议
⚠ 高频陷阱:把生成器当数组反复用
const g = take3(); [...g]; [...g] 第二次得到 []——生成器耗尽后不会重置,且调用 idMaker() 本身不执行任何函数体(新手常以为「没生效」)。需要重复遍历,就每次重新调用生成器函数拿新实例。
✓ 记忆口诀
「yield 是暂停键,next 是播放键;for...of 认协议不认类型。」

12.3 随堂自测

QUIZ 1
执行 const g = idMaker();(生成器函数)后,函数体执行了多少?
调用生成器函数只创建生成器对象,函数体处于「未启动」状态。next() 驱动执行到下一个 yield;这是惰性的核心。C 描述的是第一次 next() 之后的状态。
QUIZ 2
普通对象 {a:1, b:2} 直接用 [...obj] 报错,原因是?
展开到数组、for...of、数组解构都要求「可迭代」:对象上得有 Symbol.iterator 方法。数组/字符串/Map/Set 天生有,普通对象没有。对象展开 {...obj} 是另一套规则(复制自有可枚举属性),别混淆。
CHAPTER 13 · 工程实战

ES6+ 实用工具箱

一句话总览:解构 + 展开负责「优雅地拆与合」,?. 和 ?? 负责「安全地取值与兜底」,Map/Set 负责「对象和数组干不好的活儿」——这四件套覆盖日常 80% 的现代语法。
🧰
生活化类比
解构像按清单开箱:快递到了,直接说「我要里面的手机和耳机」(const { phone, earbuds } = box),不用一件件翻。可选链 ?. 像带保险的探路杖:路断了(null/undefined)就地停下返回 undefined,而不是摔下悬崖(TypeError)。Set 像门禁名单:同一个人刷两次也只记一条。边界:探路杖只防 null/undefined 这两种「断路」,属性存在但值是 0 或 '' 时照常通过——它不是假值过滤器。

13.1 解构与展开

es6.js
const user = { name: '润曦', addr: { city: '重庆' } };
const { name, addr: { city }, age = 18 } = user;  // 嵌套解构+默认值
const [first, ...rest] = [1, 2, 3];    // rest 收集剩余 → [2,3]

const merged = { ...user, vip: true };          // 合并,后写的覆盖先写的
const copy = [...arr];                          // 数组浅拷贝

// ?. 安全取值:任何一环是 null/undefined 就短路返回 undefined
const zip = user.addr?.zip;                     // undefined,不抛错
const len = user.tags?.length ?? 0;             // ?. 配 ?? 是黄金搭档
user.callback?.();                              // 方法存在才调用
⚠ 高频陷阱:解构 null/undefined 直接炸
const { x } = null 抛 TypeError——可选链保护取值,不保护解构。接口返回可能为空时写 const { x } = data ?? {}。另外解构默认值只在 undefined 时生效,null 会原样穿透,这是和 ?? 行为一致但常被误解的点。

13.2 Map / Set:比对象和数组更专业的容器

需求土办法专业工具优势
去重双层循环 / indexOf[...new Set(arr)]O(n),一行搞定
键是对象/数字对象键被转字符串Map任意类型当键,保持插入序
频繁增删查对象 deleteMapsize 直读,性能稳定
给 DOM 挂数据防泄漏普通 MapWeakMap键是弱引用,DOM 被移除即可回收
map-set.js
const uniq = [...new Set([1, 2, 2, 3])];   // [1,2,3]

const cache = new Map();
const keyObj = { id: 1 };
cache.set(keyObj, 'result');   // ✓ 对象本身当键
cache.get(keyObj);             // 'result'
cache.size;                    // 1

const meta = new WeakMap();
meta.set(domNode, { clicks: 0 });  // domNode 被移除后,这条数据可被 GC
✓ 记忆口诀
「拆用解构合用点(...),取值问号(?.)兜底双问号(??);去重 Set,杂键 Map,防漏 WeakMap。」

13.3 随堂自测

QUIZ 1
const { n = 5 } = { n: null }; n 的值是?
解构默认值与函数默认参数同一规则:仅当值严格等于 undefined 才启用。null 是「有值,值为空」,会原样赋给 n。想要 null 也兜底,用 const n = data.n ?? 5。
QUIZ 2
用普通对象做缓存 cache[domNode] = data,键实际是什么?
对象属性键只能是字符串/Symbol,对象键会被 toString 成 '[object Object]',所有节点互相覆盖。要拿对象当键必须用 Map;担心 DOM 移除后内存泄漏就用 WeakMap。
CHAPTER 14 · 工程实战

DOM 与事件机制

一句话总览:事件走「捕获下行 → 目标 → 冒泡上行」三段旅程;利用冒泡把监听器装在父元素上(事件委托),一个监听器管一万个子元素,动态新增的也自动生效。
🏢
生活化类比
点击一个按钮像往公司里送快递:包裹先从大门层层往下送到工位(捕获:document → body → div → button),签收后「回执」再层层往上传(冒泡:button → div → body → document)。每一层领导都可以在回执路过时盖章处理(监听器)。事件委托就是「前台统一签收」:不给每个工位配收发员,前台看回执上的寄件人(e.target)分发。边界:focus、blur 等少数事件不冒泡,回执传不上去——这类要用捕获阶段或对应的 focusin/focusout。

14.1 事件流三段与两个 target

点击 button:捕获下行,冒泡上行
document body div#list button ★目标 ① 捕获阶段(自上而下,默认监听不响应) ③ 冒泡阶段(自下而上,默认监听在此响应) e.target = button (真正被点的元素,永远不变) e.currentTarget = div#list (当前正在执行监听器的元素) stopPropagation() 拦的是"继续传播";preventDefault() 拦的是"默认行为"(跳转/提交)——两码事! focus / blur / mouseenter 不冒泡;需要委托时改用 focusin / focusout / mouseover。
委托能成立的根基:冒泡让父元素收得到子元素的事件,且 e.target 保留「真凶」身份。
delegate.js
// ❌ 给一万个 li 各装监听器:内存大、新增 li 还得补装
// ✓ 一个监听器装在父级,动态子元素自动生效
document.querySelector('#list').addEventListener('click', e => {
  const li = e.target.closest('li');       // 点到 li 内部的 span 也能定位
  if (!li) return;                         // 点在空白处,忽略
  console.log('选中:', li.dataset.id);
});
⚠ 高频陷阱:e.target 可能是子元素
li 里包着 <span> 图标时,点图标 e.target 是 span,直接判断 e.target.tagName === 'LI' 会漏掉一半点击。正确姿势:e.target.closest('li') 向上找目标容器;currentTarget 才是装监听器的元素。
✓ 记忆口诀
「捕获下、冒泡上;target 是真凶,currentTarget 是法庭;委托装父级,closest 找正主。」

14.2 随堂自测

QUIZ 1
在父 div 上委托监听 click,点击其子 button 内的 span,监听器里 e.target 是?
target 永远是事件真正的源头元素,currentTarget 才是当前监听器所在的 div。所以委托代码要用 closest('button') 从 span 向上定位,而不是直接拿 target 当 button 用。
QUIZ 2
表单 submit 监听器里调用 e.stopPropagation(),能阻止表单提交刷新页面吗?
两个 API 管两件事:stopPropagation 阻止事件继续传给祖先,preventDefault 阻止浏览器默认动作(提交/跳转/勾选)。原生 addEventListener 里 return false 没有任何效果(那是 jQuery 的语法)。
CHAPTER 15 · 工程实战

模块化:代码的「集装箱」

一句话总览:ESM(import/export)是静态、活绑定、异步加载的官方标准;CommonJS(require)是动态、值拷贝、同步加载的 Node 传统——两套系统的差异决定了打包、树摇和循环依赖的行为。
🚢
生活化类比
模块像标准集装箱:里面装什么自己说了算(私有作用域),只把贴了「出口」标签的货亮出来(export)。ESM 的进口清单在船开航前就印好了(静态分析:import 必须在顶层,打包器据此做 tree shaking 甩掉没订的货);CommonJS 是到港了现场喊要什么(require 可以写在 if 里,运行时才决定)。边界:ESM 进口的是「实时监控画面」(活绑定,出口方改值进口方跟着变),CJS 拿到的是「拍照快照」(拷贝后互不相干)。

15.1 ESM 基本姿势

math.js / app.js
// math.js —— 命名导出 + 默认导出可以共存
export const PI = 3.14159;
export function add(a, b) { return a + b; }
export default class Calculator { /* ... */ }

// app.js
import Calculator, { PI, add as sum } from './math.js';
//     ↑默认导出随便起名   ↑命名导出必须对名,可 as 重命名

// 动态导入:按需加载,返回 Promise(代码分割的基石)
const { heavyChart } = await import('./chart.js');  // 用到才下载
维度ESMCommonJS
语法import / exportrequire / module.exports
解析时机编译期静态确定(可 tree shaking)运行期动态执行(难静态分析)
导出内容活绑定(源变量更新可见)值拷贝(之后互不相干)
加载方式异步(浏览器原生支持)同步(读文件,适合服务端)
顶层 await支持不支持
⚠ 高频陷阱:浏览器里 import 不带扩展名 / 不走服务器
原生 ESM 中 import './utils' 直接 404——浏览器不做 Node 式的补全,必须写 './utils.js';双击打开 html(file:// 协议)会因 CORS 拒绝加载模块,必须起本地服务器。打包项目里能省略扩展名,那是打包器在帮忙,不是语言特性。
✓ 记忆口诀
「ESM 静态活绑定,CJS 动态拍快照;浏览器 import 要带 .js,还得 http 起服务。」

15.2 随堂自测

QUIZ 1
tree shaking(摇掉未使用代码)为什么主要依赖 ESM?
require 可以出现在任何条件分支、拼接变量路径,运行前无法确定依赖图;ESM 的 import/export 只能写在顶层且是字面量,静态可分析,未引用的导出才能被安全删除。
QUIZ 2
counter.js 导出 export let n = 0 并提供 add();ESM 导入方在 add() 后读 n,与 CJS 导入方读 n,分别是?
ESM 导入的是对源变量的只读实时引用,源头变了进口方立刻可见;CJS 的 require 拿到的是导出时刻的值拷贝,原始类型此后互不相干。这是两套模块系统最本质的语义差异。
CHAPTER 16 · 工程实战

性能与内存:防抖节流与泄漏排查

一句话总览:高频事件用防抖(等你停)或节流(按节奏)限流;JS 垃圾回收只认「可达性」——全局缓存、忘清的定时器、没摘的监听器让对象一直可达,就是内存泄漏的三大惯犯。
🛗
生活化类比
防抖是电梯关门:每进来一个人就重新计时,直到没人再进才关门出发——适合搜索框(用户停止输入才发请求)。节流是地铁发车:不管站台挤多少人,固定 3 分钟一班——适合 scroll/resize(保证稳定频率反馈)。垃圾回收是保洁阿姨:她只清「没有任何绳子拴着」的东西(不可达对象);你在全局 Map 里拴了根绳(引用),哪怕东西早没用了,阿姨也绝不敢扔。边界:阿姨不知道「你还需不需要」,只知道「有没有引用」——所以泄漏的责任永远在写代码的人。

16.1 防抖 vs 节流

同一串高频触发,两种限流的执行时机
原始触发(如连续输入 / scroll): 防抖 debounce:停止触发 300ms 后才执行一次 每簇触发的"尾巴"执行 → 搜索联想、resize 结束后重算 节流 throttle:每 300ms 最多执行一次 均匀采样 → 滚动加载、拖拽位置上报、射击游戏开火
防抖关心「最后一次」,节流关心「稳定节奏」——按业务要什么反馈来选,不是按哪个更高级。
debounce.js
function debounce(fn, wait = 300) {
  let timer = null;                    // 闭包保管定时器句柄
  return (...args) => {
    clearTimeout(timer);               // 每次触发都作废上一次预约
    timer = setTimeout(() => fn(...args), wait);
  };
}
input.addEventListener('input', debounce(e => search(e.target.value)));

function throttle(fn, gap = 300) {
  let last = 0;
  return (...args) => {
    const now = Date.now();
    if (now - last >= gap) { last = now; fn(...args); }
  };
}

16.2 内存泄漏三大惯犯与排查

惯犯泄漏机制正确姿势
忘清的定时器回调闭包引用大对象,setInterval 永不停组件卸载时 clearInterval
没摘的监听器全局对象监听器持有组件闭包removeEventListener(同一个函数引用)或 AbortController
无限增长的全局缓存Map/数组只进不出,永远可达设上限/LRU 淘汰,或 WeakMap 弱引用
游离 DOM 被 JS 引用节点已从页面移除,但变量/闭包还指着它移除节点时同步置空引用
⚠ 高频陷阱:removeEventListener 传了个"新函数"
el.addEventListener('click', () => f()) 之后再 el.removeEventListener('click', () => f()) —— 摘不掉!两个箭头函数是不同对象,移除按引用匹配。正确姿势:存下同一个函数引用,或用 AbortController 的 signal 一次性注销一组监听。
✓ 记忆口诀
「防抖等停,节流定频;GC 只看可达性——定时器要清、监听要摘、缓存要限。」排查工具:DevTools → Memory 堆快照对比 + Performance 录制看内存曲线是否只涨不落。

16.3 随堂自测

QUIZ 1
搜索框联想请求(用户停止输入后才发),应该用?
联想只关心「最终输入」,中间态请求既浪费又可能乱序返回覆盖新结果——防抖的「等停」语义正好。节流适合需要过程中持续反馈的场景(滚动进度、拖拽)。每键一请求在快输入时会打出大量无效请求。
QUIZ 2
组件销毁时执行了 clearInterval 之外的所有清理,但漏掉了 setInterval,为什么泄漏?
GC 的判据是可达性:全局定时器表引用着回调,回调闭包引用着组件数据,这条引用链让「已销毁」组件的内存永远可达。同时回调还在周期性执行,可能操作已不存在的 DOM 引发报错——泄漏与 bug 双重收益(贬义)。
渝ICP备2026024724号-1