CHAPTER 01 · 语言基础
认识 JavaScript 与运行方式
一句话总览:JS 是一门单线程、动态类型、事件驱动的语言——同一时刻只干一件事,靠「事件循环」把等待的活儿排进队列,而不是开新线程。
🍜
生活化类比
JS 引擎像一家只有一个厨师的面馆:厨师(主线程)一次只炒一份菜(执行一段代码)。遇到「炖汤要 40 分钟」(网络请求/定时器),他不会站着等,而是把汤交给后厨设备(浏览器 Web API / Node 底层),贴张单子继续炒下一份;汤好了,单子进「出餐队列」,厨师炒完手头的菜再来处理。边界:真实面馆可以多雇厨师,而 JS 主线程永远只有一个——所以一段死循环代码会「卡死整个页面」,这是类比失效的地方,也是理解 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,管理内存 |
| 宿主 API | DOM、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 三兄弟
| 特性 | var | let | const |
|---|---|---|---|
| 作用域 | 函数作用域 | 块级 {} | 块级 {} |
| 声明前使用 | 得到 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 种对象
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 比较:两条完全不同的路
=== 的心智模型只有一句话:类型不同直接 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),传家宝借出去名字也不变——所以对象方法、构造函数别用箭头函数。
普通函数像实名制的工牌:谁调用它,工牌上就临时写谁的名字(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 节点拷不了——「文件」能复制,「活人」(函数)复制不了。
浅拷贝像复印一份文件柜的目录:新目录(外层对象)是你的了,但目录里「三号抽屉」那一栏指向的还是原来那个抽屉(嵌套对象)。你往三号抽屉放东西,原柜子的主人打开一看——东西也在!深拷贝则是把每个抽屉连同内容全部复制一套。边界:structuredClone 连循环引用都能拷,但函数、DOM 节点拷不了——「文件」能复制,「活人」(函数)复制不了。
5.1 引用到底长什么样
浅拷贝后:外层是两份,内层还是一份
展开运算符只复制「第一层属性的值」;属性值若是引用,复制的是引用本身。
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 indexOf | undefined / 元素 / 布尔 / 下标 |
| 多进一出 | 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) 的折叠过程
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 循环陷阱的根源)。
函数出厂时背着一个背包,里面装着它定义处能看到的变量(外层作用域)。之后它被传到哪里执行都不重要——查变量先翻自己的口袋(局部),再翻背包(外层),一层层翻到全局,这条链就是作用域链。外层函数执行完,「厂房」拆了,但背包还被函数背着,里面的变量就拆不掉——这就是闭包。边界:背包里装的是变量本身而不是快照,变量后来变了,函数看到的也是新值(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 —— 天然的私有变量闭包的内存视角:栈帧没了,被引用的变量还活在堆里
垃圾回收只清「没人引用」的东西:闭包引用着 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 指向 |
|---|---|---|
| 1 | new Fn() | 新创建的对象 |
| 2 | fn.call(obj) / fn.bind(obj)() | 指定的 obj |
| 3 | obj.fn() | 点号前面的 obj |
| 4 | fn() 裸调用 | 严格模式 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 是怎么被找到的:三级原型链
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 是真的会无限清微任务直到饿死渲染。
厨师(主线程)炒菜规则:① 手头的菜炒完(清空调用栈);② 先看加急单(微任务队列),有多少做多少,一张不剩;③ 再从普通单(宏任务队列)里只取一张做;④ 做完又回到②。加急单永远插队,且会「做到没有为止」——所以疯狂产生微任务会让普通单和上菜(页面渲染)永远轮不上。边界:真实厨房加急单再多也会累,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;下一轮宏任务才轮到 B9.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),每张登记都会各自收到通知。
点外卖拿到一张取餐小票(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 的结果(先洗完才能晾),那只能串行——依赖关系决定能不能并发。
洗衣服(请求 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 只是决定你什么时候收结果。
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 }),不按就不生产——要一百万瓶也不用先造一百万瓶(惰性)。
普通数组像整箱矿泉水:一次搬回家,占地方。生成器像自动售货机:你按一次按钮(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 | 任意类型当键,保持插入序 |
| 频繁增删查 | 对象 delete | Map | size 直读,性能稳定 |
| 给 DOM 挂数据防泄漏 | 普通 Map | WeakMap | 键是弱引用,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)。每一层领导都可以在回执路过时盖章处理(监听器)。事件委托就是「前台统一签收」:不给每个工位配收发员,前台看回执上的寄件人(
点击一个按钮像往公司里送快递:包裹先从大门层层往下送到工位(捕获:document → body → div → button),签收后「回执」再层层往上传(冒泡:button → div → body → document)。每一层领导都可以在回执路过时盖章处理(监听器)。事件委托就是「前台统一签收」:不给每个工位配收发员,前台看回执上的寄件人(
e.target)分发。边界:focus、blur 等少数事件不冒泡,回执传不上去——这类要用捕获阶段或对应的 focusin/focusout。14.1 事件流三段与两个 target
点击 button:捕获下行,冒泡上行
委托能成立的根基:冒泡让父元素收得到子元素的事件,且 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 拿到的是「拍照快照」(拷贝后互不相干)。
模块像标准集装箱:里面装什么自己说了算(私有作用域),只把贴了「出口」标签的货亮出来(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'); // 用到才下载| 维度 | ESM | CommonJS |
|---|---|---|
| 语法 | import / export | require / 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 里拴了根绳(引用),哪怕东西早没用了,阿姨也绝不敢扔。边界:阿姨不知道「你还需不需要」,只知道「有没有引用」——所以泄漏的责任永远在写代码的人。
防抖是电梯关门:每进来一个人就重新计时,直到没人再进才关门出发——适合搜索框(用户停止输入才发请求)。节流是地铁发车:不管站台挤多少人,固定 3 分钟一班——适合 scroll/resize(保证稳定频率反馈)。垃圾回收是保洁阿姨:她只清「没有任何绳子拴着」的东西(不可达对象);你在全局 Map 里拴了根绳(引用),哪怕东西早没用了,阿姨也绝不敢扔。边界:阿姨不知道「你还需不需要」,只知道「有没有引用」——所以泄漏的责任永远在写代码的人。
16.1 防抖 vs 节流
同一串高频触发,两种限流的执行时机
防抖关心「最后一次」,节流关心「稳定节奏」——按业务要什么反馈来选,不是按哪个更高级。
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 双重收益(贬义)。