把「作用域链」讲透：6 道面试题背后的编译期/执行期 + 一次讲清 JS 垃圾回收（GC）你会发现：大多数作用域链题，不

你会发现：大多数作用域链题，不是在考你“会不会算输出” ，而是在考你能不能把 JavaScript 运行时拆成两句话讲清楚：

编译期：声明（var/function）先“挂上去”（提升），但赋值不提升
执行期：读/写变量都沿着作用域链找（找不到时的行为决定了坑有多深）

下面我用一套“固定解题模板”把 6 道题讲到可迁移，然后把 GC 也用同样的思路讲成体系。内容与题目、图片全部保留并强化讲解。

一套通用解题模板：作用域链题别背答案

以后看到任何“打印输出题”，你就按这个模板走，十题九稳：

Step 0：先画作用域（只要三件事）

变量/函数分别声明在哪一层作用域
函数定义位置（决定它的父级作用域，也就是“词法作用域”）
执行时从“当前作用域 → 父级 → … → 全局”查找

Step 1：拆成编译期 & 执行期

编译期：var 声明提升，初始值是 undefined；函数声明也提升（更强）
执行期：
- 读变量（RHS） ：我要“取值”，沿作用域链找
- 写变量（LHS） ：我要“赋值”，也沿作用域链找，找不到会触发“隐式全局”（非严格模式）

你能把“这题是在编译期埋坑，还是执行期沿链找到/找不到导致的”说清楚，基本就过关了。

题 1：函数里改全局变量，为什么立刻生效？

var n = 100
function foo(){
  n = 200
}
foo()
console.log(n) // 200

结论：输出 200。

按模板拆解

作用域定位：n 声明在全局（GO），foo 的父级作用域也是全局。
执行期（LHS 赋值） ：在 foo 内执行 n = 200，引擎会沿作用域链找 n：当前作用域没有 → 去全局找到 n → 直接改掉全局 n。

更“面试官爱听”的一句话

这是一次 LHS 引用：赋值操作会沿作用域链定位到“最近的同名变量”，这里最近的是全局的 n，所以全局被改写。

图示（保留原图）

题 2：同名变量 + var 提升：为什么先 undefined 再正常？

function foo(){
  console.log(m)
  var m = "吴"
  console.log(m);
}
var m = "why"
foo()
// undefined
// 小吴

结论：第一次打印 undefined，第二次打印 "小吴"。

关键点只有一个：遮蔽 + var 提升

foo 里也声明了 var m，它会在 编译期提升到 foo 作用域顶部，初始为 undefined
因为“就近原则”，foo 内部对 m 的读写都优先命中 函数自己的 m，外层的 m="why" 被遮蔽了。

等价于：

var m
function foo(){
  var m
  console.log(m) // undefined（提升后的默认值）
  m = "小吴"
  console.log(m) // "小吴"
}
m = "why"
foo()

常见追问怎么答

问：为啥不是打印外层 "why"？
答：因为 foo 作用域里存在同名 m，查找在命中第一个同名标识符时停止，形成遮蔽。

题 3：父级作用域看“函数写在哪”，不看“在哪调用”

var n = 100

function foo1(){
  console.log("这是foo1内部",n);
}

function foo2(){
  var n = 200
  console.log("这是foo2内部",n);
  foo1()
}

foo2()
console.log("这是最外层",n);

结论输出顺序：

foo2 内部：200
foo1 内部：100
最外层：100

核心原因：词法作用域（lexical scope）

foo1 定义在全局，它的父级作用域就是全局
即使它在 foo2 里被调用，它也不会“认 foo2 当爹”

一句话总结：

作用域链 = 写代码时就确定的链（函数写在哪决定父级作用域），不是运行时调用栈决定的。

题 4：return 前的 var 也会提升：为什么拿不到全局的 a？

var a = 100

function foo(){
  console.log(a)
  return
  var a = 200
}

foo() // undefined

结论：打印 undefined。

为什么这题特别“阴”？

很多人以为 return 之后代码不执行，所以 var a 不存在
但 var 是编译期处理：var a 依然会被提升到函数顶部，初始值 undefined

等价于：

var a = 100
function foo(){
  var a
  console.log(a) // undefined（命中的是函数内 a）
  return
  a = 200
}
foo()

一句话加分

这题不是在考 return，而是在考 “var 提升会提前制造一个同名变量，从而遮蔽外层变量” 。

题 5：`var a = b = 10`：谁是全局变量？

function foo(){
  var a = b = 10
}
foo()
console.log(a);
console.log(b);

结论：a 报错（未定义），b 是 10（非严格模式下）。

拆解（从右往左）
var a = b = 10 实际上是：

b = 10       // 注意：没有声明！
var a = b

a：被 var 声明在 foo 作用域内，函数外拿不到
b：没有 var/let/const，在非严格模式下会变成隐式全局变量（挂到全局对象上）

面试官很爱追问：严格模式呢？

严格模式下：b = 10 会直接抛 ReferenceError，因为禁止隐式全局。

补充：隐式全局变量到底有多危险

function foo(){
  m = 200
}
foo()
console.log(m); // 200

这段之所以能跑，是因为非严格模式下 m 被“偷偷”挂到全局上了。
真实项目里它会带来：

污染全局命名空间（更容易冲突）
更难定位数据来源（调试成本爆炸）
更容易产生“意外长生命周期对象”（和内存问题强相关）

建议：业务代码默认开启严格模式 / 使用 ESM（天然严格）+ ESLint（no-undef / no-global-assign）。

垃圾回收 GC：从堆/栈到可达性

如果说“作用域链”是在解释变量怎么找，那 GC 就是在解释对象什么时候死。

先记住一句话：

内存有限，所以不再需要的对象必须被回收；关键问题是：GC 怎么判断“你不需要了”？

堆 vs 栈：到底谁存什么？

栈（Stack） ：放基础类型的值、以及引用类型的“地址/指针”
堆（Heap） ：放对象实例本体（数组、对象、函数对象等）

文中这部分总结得很清楚：基础类型偏栈，复杂类型偏堆，栈里保存指向堆的引用。

图示（保留原图）

两大核心算法：引用计数 vs 标记清除

1）引用计数（Reference Counting）

思路很直观：对象记录自己被引用了几次（retain count）。

引用 +1，断开 -1
计数变 0 → 可以回收

致命缺陷：循环引用

var obj1 = {friend:obj2}
var obj2 = {friend:obj1}

两个对象互相引用，计数永远不为 0 → 回收不了 → 内存泄漏。

图示（保留原图）：

2）标记清除（Mark-Sweep）：JS 最主流的“可达性”路线

V8 等 JS 引擎主流使用“可达性”（Reachability）：从“根对象”出发，能走到的对象就是活的。

过程

从 root 出发遍历引用图，能到达的标记为“可达”
没被标记的就是“不可达” → 清除回收

它为什么能解决循环引用？

循环引用本身不重要，重要的是：这坨循环是否还能从 root 到达
到不了，就是垃圾，一样清。

图示（保留原图）：

V8 为啥更快：分代、增量、闲时、整理

现实世界里，“一次性全量标记清除”会带来 STW（暂停）和碎片问题，所以引擎会做工程级优化：

标记整理（Mark-Compact） ：回收时把存活对象往一边搬，减少碎片
分代收集（Generational） ：新对象死得快（新生代频繁收），老对象活得久（老生代低频收）
增量收集（Incremental） ：把一次长暂停拆成多段小暂停
闲时收集（Idle-time） ：尽量在 CPU 空闲时做 GC，降低卡顿感

V8 的堆内存分区（保留原图）：

面试加分：如何从代码层面避免内存问题

GC 是“清理工”，但你写代码时决定了垃圾是“可达”还是“不可达”。下面这些回答，既能落地又能加分：

不要制造意外长生命周期引用

全局变量、单例缓存、模块级 Map/Array：如果只增不删，对象就一直可达
解决：设计“上限 + 淘汰策略”（LRU / TTL），或者主动 delete/clear

事件监听与定时器要能解除

addEventListener / setInterval 如果不移除，会让回调闭包一直可达
解决：组件卸载/页面销毁时 removeEventListener、clearInterval

避免隐式全局

m = 200 这种写法会把对象挂到全局，生命周期直接拉满
解决：严格模式 + ESLint

理解“可达性”的调试方式

当你怀疑泄漏：不是问“GC 为什么不回收”，而是问

“是谁还在引用它？从 root 到它的引用链是什么？”

结尾：把知识变成“可迁移能力”

你会发现，题目怎么变都逃不掉这两条主线：

作用域链题：编译期提升 + 执行期沿链查找（读/写）
内存题：对象是否还可达（谁还在引用它）

后续如果你要接着写“闭包”那一章，这篇其实已经把最关键的地基铺好了：闭包的本质，就是“让某些变量在函数执行完后依然可达”，从而延长它的生命周期。

把「作用域链」讲透：6 道面试题背后的编译期/执行期 + 一次讲清 JS 垃圾回收（GC）