第6章：V8 优化 —— 让 JavaScript 更快

“V8 不是被动执行，而是主动优化：上下文折叠、内联缓存、垃圾回收。”
—— 当你看到“O(1) 查找”，你就看穿了 V8 的“加速引擎”。

引言：V8 不只是一个解释器

很多人以为 V8 是“读一行，执行一行”。

错。

V8 是一个主动优化的 JIT（即时编译）引擎。它不仅执行代码，还会：

• 分析你的代码模式
• 预测变量访问路径
• 优化内存和查找性能

本章，我们将揭示 V8 如何通过三大核心技术，让 JavaScript 快如闪电。

1. 上下文折叠（Context Folding）—— 减少堆分配

问题：Context 在堆上，创建和销毁慢

• 每次函数调用都创建 Context？太贵了！
• 尤其是那些没有闭包的函数

解决方案：上下文折叠

V8 的优化策略：

如果函数没有闭包，且变量未被捕获，V8 直接在栈帧中分配变量，跳过 Context 创建！

示例：

function simpleAdd(a, b) {
  let temp = a + b;
  return temp * 2;
}
simpleAdd(3, 4);

优化前（无折叠）：

[栈帧]
  context → Context_simpleAdd
            │
            ├─ variables_[0]: a = 3
            ├─ variables_[1]: b = 4
            └─ variables_[2]: temp = 7

优化后（上下文折叠）：

[栈帧]
  a: 3
  b: 4
  temp: 7
  // 没有 Context！变量直接存在栈帧中

效果

• 避免堆内存分配
• 减少 GC 压力
• 变量访问更快（栈访问比堆快）

只有被闭包捕获的变量，才需要 Context

2. 内联缓存（Inline Caching, IC）—— 加速变量查找

问题：作用域链查找是 O(n)

function outer() {
  let x = 1;
  function inner() {
    console.log(x); // 每次都要遍历作用域链？
  }
  for (let i = 0; i < 1e6; i++) inner();
}

如果每次 inner() 都要从 [[Environment]] 开始跳转查找 x，性能将急剧下降。

解决方案：内联缓存（IC）

V8 的优化过程：

第一次执行 inner()：

1. 沿 [[Environment]] 查找 x
2. 找到 x 在 Context_outer 的 variables_[0]
3. 缓存这个 slot 位置

后续执行：

• 直接通过 Context_outer.variables_[0] 读取 x
• 时间复杂度：O(1)

内联缓存的类型

类型	说明
未初始化（Uninitialized）	还未执行过
单态（Monomorphic）	只有一种类型/位置，缓存命中
多态（Polymorphic）	多个类型，缓存多个 slot
巨态（Megamorphic）	类型太多，缓存失效，回退到慢路径

最佳性能：单态缓存
尽量让变量类型和结构保持一致！

3. 垃圾回收（GC）—— 自动内存管理

GC 的核心任务

• 回收不再使用的 Context 对象
• 释放被闭包“绑架”的内存
• 防止内存泄漏

V8 的 GC 算法：分代 + 标记-清除

1. 分代回收（Generational GC）

• 新生代（Young Generation）：存放短期对象（如局部变量）
  • 使用 Scavenge 算法（快速复制）
• 老生代（Old Generation）：存放长期对象（如闭包中的 Context）
  • 使用 标记-清除（Mark-Sweep） 和 标记-整理（Mark-Compact）

2. 标记-清除（Mark-Sweep）流程

1. 标记（Mark）：
   • 从根（Roots）开始：全局对象、调用栈中的变量、[[Environment]] 指针
   • 遍历所有可达对象，标记为“活跃”
2. 清除（Sweep）：
   • 遍历堆内存
   • 回收所有未被标记的对象（如不可达的 Context）

示例：闭包被释放时

const fn = createClosure();
fn(); // 使用
fn = null; // 断开引用

// 下次 GC：
// 从根开始，找不到指向 fn 的路径
// fn → 不可达
// fn.[[Environment]] → Context → 不可达
// Context 和其中变量被回收

本章核心结论

V8 不是“忠实执行者”，而是“聪明的优化者”。

优化技术	作用	开发者启示
上下文折叠	避免不必要的 Context 创建	无闭包的函数更快
内联缓存	变量查找从 O(n) → O(1)	保持变量结构稳定
垃圾回收	自动回收不可达的 Context	主动断开闭包引用

如何写出被 V8 喜欢的代码？

1. 避免不必要的闭包
   • 能不用闭包就不用
   • 减少 Context 创建
2. 保持变量类型一致
   • 让 IC 保持“单态”
   • 避免 x = 1; x = "str"; x = {};
3. 及时清理引用
   • 闭包使用完后 fn = null
   • 防止内存泄漏
4. 避免在循环中创建闭包捕获大对象
   • 拆分作用域，显式传参