# 编译器和解析器：V8如何执行一段JavaScript代码的|浏览器篇

> 本文深入解析V8引擎如何执行JavaScript代码，详细介绍编译器、解释器、抽象语法树（AST）、字节码、JIT等核心概念，帮助前端开发者理解JavaScript底层执行机制及其在现代浏览器中的应用。

- 原文：https://feinterview.poetries.top/docs/fe-base-docs/browser/part3/14-%E7%BC%96%E8%AF%91%E5%99%A8%E5%92%8C%E8%A7%A3%E6%9E%90%E5%99%A8%EF%BC%9AV8%E5%A6%82%E4%BD%95%E6%89%A7%E8%A1%8C%E4%B8%80%E6%AE%B5JavaScript%E4%BB%A3%E7%A0%81%E7%9A%84
- 来源：前端进阶之旅（feinterview.poetries.top）
- 更新：2026.10.03
- 可见范围：免费部分

---

## 编译器和解析器：V8如何执行一段JavaScript代码的

- 这一章要串起的主线：源码 → `AST` + 作用域 → 字节码 → 解释执行 → 热点代码编译成机器码
- 关键名词：编译器、解释器、`AST`、字节码、`JIT`，要能连成一条链讲，别孤立背
- `Babel`、`ESLint`、`Prettier` 都是基于 `AST` 干活：解析 → 遍历改树 → 生成代码
- 工具的 `AST`（`ESTree`）和 `V8` 内部的 `AST` 是两套东西，思路一样结构不同

**这一章讲的是 `V8` 拿到一段 `JS` 源码后，怎么一步步把它变成能跑的东西，核心是 `AST`、字节码和 `JIT` 这条链。** 我一般这么串：源码先被解析成 `AST`，同时确定作用域；然后解释器 `Ignition` 把 `AST` 翻成字节码边翻边跑；跑得多的热点函数再交给优化编译器编成机器码。学这条链的好处是很多工具一下就通了，`Babel` 转语法、`ESLint` 查规则，本质都是「解析成 `AST`，改树或检查树，再生成代码」。

前面我们已经花了很多篇幅来介绍 JavaScript 是如何工作的，了解这些内容能帮助你从底层理解 JavaScript 的工作机制，从而能帮助你更好地理解和应用 JavaScript。

今天这篇文章我们就继续“向下”分析，站在 JavaScript 引擎 V8 的视角，来分析 JavaScript 代码是如何被执行的。

前端工具和框架的自身更新速度非常块，而且还不断有新的出现。要想追赶上前端工具和框架的更新速度，你就需要抓住那些本质的知识，然后才能更加轻松地理解这些上层应用。比如我们接下来要介绍的 V8 执行机制，能帮助你从底层了解 JavaScript，也能帮助你深入理解语言转换器 Babel、语法检查工具 ESLint、前端框架 Vue 和 React 的一些底层实现机制。因此，了解 V8 的编译流程能让你对语言以及相关工具有更加充分的认识。

要深入理解 V8 的工作原理，你需要搞清楚一些概念和原理，比如接下来我们要详细讲解的编译器（Compiler）、解释器（Interpreter）、抽象语法树（AST）、字节码（Bytecode）、即时编译器（JIT）等概念，都是你需要重点关注的。

**原理拆解：** 源码进入 `V8` 后，首先经过词法和语法分析，形成表达程序结构的 `AST`；声明处理还会参与建立执行上下文。随后引擎把可执行结构转换成字节码，由解释器运行。运行过程中收集到的类型与调用信息，可以支持优化编译器为热点路径生成更高效的机器码；假设失效时，引擎可能退回较通用的执行形式。

**最小验证：** 输入两段源码：第一段只有函数声明，第二段包含非法语法。要验证的结论是“编译成功”和“函数真正执行”是两个不同阶段。以下代码可直接由现代 `Node.js` 执行：

```javascript
const vm = require('node:vm');

const validSource = `
  function add(a, b) {
    console.log('function body executed');
    return a + b;
  }
  add;
`;

const script = new vm.Script(validSource);
console.log('compiled');
const add = script.runInNewContext({ console });
console.log('loaded:', typeof add);
console.log('result:', add(2, 3));

try {
  new vm.Script('function broken( {');
} catch (error) {
  console.log('syntax:', error.name);
}
```

`new vm.Script` 会先解析并编译源码，但不会调用 `add`；`runInNewContext` 执行顶层代码并返回函数，最后一次调用才打印函数体日志。预期依次看到 `compiled`、`loaded: function`、函数体日志、`result: 5` 和 `syntax: SyntaxError`。

**边界与排查：** 这个实验只能观察阶段差异，不能直接取得 `V8` 内部的 `AST`、字节码或优化机器码。一次运行耗时也不能证明发生了 `JIT` 优化，因为预热、垃圾回收和系统调度都会干扰结果。分析 `Babel`、`ESLint` 时还应区分它们自己的解析器产物与 `V8` 内部表示：概念链路相似，节点结构和用途并不相同。

- **`Babel` 把箭头函数转成普通函数，大致经历了哪几步？**

  三步：`@babel/parser` 把源码解析成 `AST`；插件遍历 `AST`，把 `ArrowFunctionExpression` 节点换成 `FunctionExpression`；`@babel/generator` 再把树打印回代码。和 `V8` 的前半段是一个思路。

- **`ESLint` 用的 `AST` 和 `V8` 里的是同一个吗？**

  不是。`ESLint` 用 `espree` 产出 `ESTree` 规范的 `AST`，是给工具用的；`V8` 的 `AST` 是引擎内部结构，外面拿不到。思路相通，节点格式不能互换。

- **前端工具一年一换，为什么还要学这些底层的？**

  工具换的是外壳，解析、作用域、编译这些是几十年没怎么变的基础。懂了这条链，看到 `SWC`、`esbuild`、`Oxc` 这些新工具，一眼就知道它们在哪一步做了什么、快在哪。

- **想快速看一段代码的 `AST` 长什么样，怎么办？**

  打开 `astexplorer.net`，选好 `parser`（比如 `@babel/parser`）贴代码就能看到树。写 `Babel` 插件或自定义 `ESLint` 规则时基本离不开它。

## 编译器和解释器

- 编译型语言：先整体编译成机器码再运行（`C++`、`Go`），启动慢、执行快
- 解释型语言：运行时由解释器边翻译边执行，启动快、执行慢
- `JS` 在 `V8` 里两者都有：先解释执行字节码，热点代码再 `JIT` 编译成机器码
- 两条路都要先解析：词法分析 → 语法分析 → `AST`
- 别说「`JS` 是纯解释型语言」，现代引擎早就不是了

**编译器是运行前把整段代码翻成机器码，解释器是运行时一句句翻一句句执行，`V8` 是两种结合着用的。** 打个比方，编译器像把整本书翻译完再出版，前期慢，读起来快；解释器像同声传译，马上能开讲，但每次都要现翻。两条路前面都一样，先做词法分析和语法分析得到 `AST`。`JS` 早期是纯解释，现在的 `V8` 先把 `AST` 转成字节码让解释器跑，发现某个函数调用特别频繁，再交给优化编译器编成机器码，这就是 `JIT`。

之所以存在编译器和解释器，是因为机器不能直接理解我们所写的代码，所以在执行程序之前，需要将我们所写的代码“翻译”成机器能读懂的机器语言。按语言的执行流程，可以把语言划分为编译型语言和解释型语言。

编译型语言在程序执行之前，需要经过编译器的编译过程，并且编译之后会直接保留机器能读懂的二进制文件，这样每次运行程序时，都可以直接运行该二进制文件，而不需要再次重新编译了。比如 C/C++、GO 等都是编译型语言。

而由解释型语言编写的程序，在每次运行时都需要通过解释器对程序进行动态解释和执行。比如 Python、JavaScript 等都属于解释型语言。

那编译器和解释器是如何“翻译”代码的呢？具体流程你可以参考下图

![](https://s.poetries.top/gitee/2019/11/19.png)

从图中你可以看出这二者的执行流程，大致可阐述为如下：

1. 在编译型语言的编译过程中，编译器首先会依次对源代码进行词法分析、语法分析，生成抽象语法树（AST），然后是优化代码，最后再生成处理器能够理解的机器码。如果编译成功，将会生成一个可执行的文件。但如果编译过程发生了语法或者其他的错误，那么编译器就会抛出异常，最后的二进制文件也不会生成成功
2. 在解释型语言的解释过程中，同样解释器也会对源代码进行词法分析、语法分析，并生成抽象语法树（AST），不过它会再基于抽象语法树生成字节码，最后再根据字节码来执行程序、输出结果。

- **`JS` 到底是编译型还是解释型？**

  按语言规范它不规定怎么执行；按 `V8` 的实现，是解释加即时编译的混合模式。面试里直接说「`JS` 是解释型」会被追问，最好说「先解释执行字节码，热点代码 `JIT` 编译成机器码」。

- **为什么 `V8` 不像 `C++` 那样提前全部编译成机器码？**

  网页要求快速启动，几 `MB` 的脚本全编成机器码太慢、太占内存。而且 `JS` 是动态类型，不运行就不知道变量是什么类型，提前编出来的代码没法特化。

- **词法分析和语法分析分别产出什么？**

  词法分析把字符流切成 `token`，比如 `var`、`a`、`=`、`1`；语法分析按语法规则把 `token` 组装成 `AST`，这一步如果不合语法就抛 `SyntaxError`。

- **为什么一段代码有语法错误，前面的 `console.log` 也不会执行？**

  因为整段脚本要先解析成功才开始执行，语法分析阶段就报了 `SyntaxError`，执行阶段根本没开始。运行时错误（比如 `undefined` 上取属性）才会让前面的代码先执行完。

## V8 是如何执行一段 JavaScript 代码的

- 流程：源码 → 解析器生成 `AST` + 作用域 → `Ignition` 生成字节码并解释执行 → 热点代码交给优化编译器 → 机器码
- 字节码介于 `AST` 和机器码之间：比机器码省内存，比直接解释 `AST` 快
- 惰性解析：没被调用的函数只做预解析（检查语法），真调用时才完整解析生成字节码
- 版本差异：老 `V8` 用 `Full-codegen` + `Crankshaft`；`V8 5.9`（2017）起是 `Ignition` + `TurboFan`；后来又加了 `Sparkplug`（`Chrome 91`）和 `Maglev`（`Chrome 117`）两层
- 类型假设失败会去优化（`deopt`），退回字节码执行

**`V8` 执行 `JS` 的主线是：解析成 `AST` 和作用域，`Ignition` 把它转成字节码边转边跑，跑得热的函数再交给优化编译器编成机器码。** 为什么要有字节码，是因为早期 `V8` 直接把 `AST` 编成机器码，手机上内存占用太大，字节码体积小得多。优化编译器会根据运行时收集到的类型反馈做假设，比如「这个参数一直是数字」，然后生成专门的机器码；一旦传进来个字符串，假设破了就去优化，退回字节码。现在 `Chrome` 里其实是四层：`Ignition`、`Sparkplug`、`Maglev`、`TurboFan`，越往后越快、编译越贵。

```mermaid
sequenceDiagram
    autonumber
    participant Src as JS 源码
    participant P as 解析器
    participant I as Ignition 解释器
    participant T as 优化编译器
    participant CPU as CPU
    Src->>P: 交给 V8 解析
    P->>P: 词法分析和语法分析
    P-->>I: 生成 AST 和作用域
    I->>I: 生成字节码
    I->>CPU: 逐条解释执行字节码
    I->>I: 收集类型反馈和调用次数
    opt 函数调用变热
        I->>T: 提交热点函数和类型反馈
        T-->>CPU: 生成特化机器码并执行
    end
    alt 类型假设被打破
        CPU-->>I: 去优化，退回字节码执行
    else 假设一直成立
        CPU-->>CPU: 继续跑优化后的机器码
    end
```

通过上面的介绍，相信你已经了解编译器和解释器了。那接下来，我们就重点分析下 V8 是如何执行一段 JavaScript 代码的。你可以先来“一览全局”，参考下图：

![](https://s.poetries.top/gitee/2019/11/20.png)

从图中可以清楚地看到，V8 在执行过程中既有解释器 Ignition，又有编译器 TurboFan，那么它们是如何配合去执行一段 JavaScript 代码的呢? 下面我们就按照上图来一一分解其执行流程。

**1. 生成抽象语法树（AST）和执行上下文**

将源代码转换为抽象语法树，并生成执行上下文，而执行上下文我们在前面的文章中已经介绍过很多了，主要是代码在执行过程中的环境信息。

那么下面我们就得重点讲解下抽象语法树（下面表述中就直接用它的简称 AST 了），看看什么是 AST 以及 AST 的生成过程是怎样的。

高级语言是开发者可以理解的语言，但是让编译器或者解释器来理解就非常困难了。对于编译器或者解释器来说，它们可以理解的就是 AST 了。所以无论你使用的是解释型语言还是编译型语言，在编译过程中，它们都会生成一个 AST。这和渲染引擎将 HTML 格式文件转换为计算机可以理解的 DOM 树的情况类似。

你可以结合下面这段代码来直观地感受下什么是 AST：

```js
var myName = " 极客时间 "
function foo(){
  return 23;
}
myName = "geektime"
foo()
```

这段代码经过javascript-ast站点处理后，生成的 AST 结构如下：

![](https://s.poetries.top/gitee/2019/11/21.png)

从图中可以看出，AST 的结构和代码的结构非常相似，其实你也可以把 AST 看成代码的结构化的表示，编译器或者解释器后续的工作都需要依赖于 AST，而不是源代码。

AST 是非常重要的一种数据结构，在很多项目中有着广泛的应用。其中最著名的一个项目是 Babel。Babel 是一个被广泛使用的代码转码器，可以将 ES6 代码转为 ES5 代码，这意味着你可以现在就用 ES6 编写程序，而不用担心现有环境是否支持 ES6。Babel 的工作原理就是先将 ES6 源码转换为 AST，然后再将 ES6 语法的 AST 转换为 ES5 语法的 AST，最后利用 ES5 的 AST 生成 JavaScript 源代码。

除了 Babel 外，还有 ESLint 也使用 AST。ESLint 是一个用来检查 JavaScript 编写规范的插件，其检测流程也是需要将源码转换为 AST，然后再利用 AST 来检查代码规范化的问题。

现在你知道了什么是 AST 以及它的一些应用，那接下来我们再来看下 AST 是如何生成的。通常，生成 AST 需要经过两个阶段。

**第一阶段是分词（tokenize），又称为词法分析**，其作用是将一行行的源码拆解成一个个 token。所谓token，指的是语法上不可能再分的、最小的单个字符或字符串。你可以参考下图来更好地理解什么 token。

![](https://s.poetries.top/gitee/2019/11/22.png)

---

> 以上是免费部分。完整内容需要「前端进阶之旅」会员，原文：https://feinterview.poetries.top/docs/fe-base-docs/browser/part3/14-%E7%BC%96%E8%AF%91%E5%99%A8%E5%92%8C%E8%A7%A3%E6%9E%90%E5%99%A8%EF%BC%9AV8%E5%A6%82%E4%BD%95%E6%89%A7%E8%A1%8C%E4%B8%80%E6%AE%B5JavaScript%E4%BB%A3%E7%A0%81%E7%9A%84
