# 调用栈：为什么JavaScript代码会出现栈溢出|浏览器篇

> 本文深入解析JavaScript调用栈的工作原理，讲解函数调用、执行上下文与栈溢出错误的成因，帮助前端开发者理解浏览器中代码执行流程及常见的栈溢出问题解决思路。

- 原文：https://feinterview.poetries.top/docs/fe-base-docs/browser/part2/08-%E8%B0%83%E7%94%A8%E6%A0%88%EF%BC%9A%E4%B8%BA%E4%BB%80%E4%B9%88JavaScript%E4%BB%A3%E7%A0%81%E4%BC%9A%E5%87%BA%E7%8E%B0%E6%A0%88%E6%BA%A2%E5%87%BA
- 来源：前端进阶之旅（feinterview.poetries.top）
- 更新：2026.10.08
- 可见范围：免费部分

---

## 调用栈：为什么JavaScript代码会出现栈溢出

- 三种情况会创建执行上下文：全局代码（整个页面一份）、每次函数调用、`eval`
- 函数执行完，它的执行上下文一般就出栈销毁了（闭包引用的变量另说）
- 调用栈管理的是「还没执行完的同步调用」，不是调用历史
- 栈溢出 = 调用链只进不出，超过引擎的栈大小上限，抛 `RangeError: Maximum call stack size exceeded`
- 上限不是固定层数，看引擎、栈帧大小；深度不可控的递归改循环或手动栈

**栈溢出就是函数一层套一层地调，前面的都没返回，调用栈被撑满了。** 每调用一个函数，引擎就往调用栈里压一个执行上下文，函数返回再弹出来。正常嵌套调用很快就弹回去了，但没有终止条件的递归每一层都在等下一层，只进不出，到了引擎的上限就报 `RangeError: Maximum call stack size exceeded`。

```js
function recurse(n) { return recurse(n + 1) } // 没有终止条件
try { recurse(0) } catch (e) { console.log(e instanceof RangeError) } // true
```

具体多少层会爆不固定，`Chrome` 下简单函数一般是一万层上下，局部变量多的函数会更早爆。

在上篇文章中，我们讲到了，当一段代码被执行时，JavaScript引擎先会对其进行编译，并创建执行上下文。但是并没有明确说明到底什么样的代码才算符合规范

那么接下来我们就来明确下，哪些情况下代码才算是“一段”代码，才会在执行之前就进行编译并创建执行上下文。一般说来，有这么三种情况

- 当JavaScript执行全局代码的时候，会编译全局代码并创建全局执行上下文，而且在整个页面的生存周期内，全局执行上下文只有一份。
- 当调用一个函数的时候，函数体内的代码会被编译，并创建函数执行上下文，一般情况下，函数执行结束之后，创建的函数执行上下文会被销毁。
- 当使用eval函数的时候，eval的代码也会被编译，并创建执行上下文。

好了，又进一步理解了执行上下文，那本节我们就在这基础之上继续深入，一起聊聊调用栈。学习调用栈至少有以下三点好处：

- 可以帮助你了解JavaScript引擎背后的工作原理；
- 让你有调试JavaScript代码的能力；
- 帮助你搞定面试，因为面试过程中，调用栈也是出境率非常高的题目

比如你在写JavaScript代码的时候，有时候可能会遇到栈溢出的错误，如下图所示：

![](https://s.poetries.top/images/202203011702473.png)

那为什么会出现这种错误呢？这就涉及到了调用栈的内容。你应该知道JavaScript中有很多函数，经常会出现在一个函数中调用另外一个函数的情况，调用栈就是用来管理函数调用关系的一种数据结构。因此要讲清楚调用栈，你还要先弄明白函数调用和栈结构

**原理拆解：** 执行经典脚本时，引擎先建立全局执行上下文；每次普通函数调用又会创建对应的函数执行上下文，并把代表该次调用的栈帧压入调用栈。函数返回后，栈帧按后进先出的顺序弹出，调用者才继续执行。`eval` 执行的字符串也要被解析、编译并在相应执行环境中运行。调用栈管理的是尚未完成的同步调用关系，不是所有已经调用过的函数历史。

**最小验证：** 输入以下代码，要验证正常嵌套调用的入栈与出栈顺序，以及无终止条件的递归会持续累积栈帧。

```javascript
function third() {
  console.trace("stack in third");
  return 3;
}

function second() {
  return third() + 2;
}

function first() {
  return second() + 1;
}

console.log(first());

function recurse(depth) {
  return recurse(depth + 1);
}

try {
  recurse(0);
} catch (error) {
  console.log(error.name);
  console.log(error instanceof RangeError);
}
```

`console.trace` 展示的调用路径应包含 `third`、`second`、`first`，随后 `console.log` 输出 `6`，说明返回值沿相反方向逐层传回。`recurse` 没有基线条件，每次调用都必须等待下一层返回，栈帧无法弹出；达到当前引擎允许的深度后，通常会捕获到 `RangeError`，第二项输出 `true`。

**边界与排查：** 最大栈深度属于引擎和运行环境的实现限制，不能依赖某个固定数字；不同浏览器版本、启动参数和函数体复杂度都可能改变触发位置。异步回调通常会在后续任务中重新进入调用栈，不会像同步递归一样保留整条调用链。工程排查可结合错误堆栈寻找重复帧，并检查递归终止条件是否可达；数据规模不受控时，可改用显式数组模拟栈或用循环完成遍历。

- **监控显示调用了几万次函数，有人说调用栈会存下所有调用过的函数迟早溢出，对吗？**

  不对。调用栈只存还没返回的调用，函数返回就弹出了。调用一百万次但每次都返回，栈深度始终只有几层。

- **线上报 `Maximum call stack size exceeded`，本地复现不了，怎么查？**

  看错误堆栈里反复出现的函数名，大概率是递归的终止条件依赖了某些线上数据，比如树形数据里有环、或者层级特别深。也查一下 `A` 调 `B`、`B` 又调 `A` 的互相递归，比如 `setter` 里又给自己赋值。

- **递归遍历用户输入的树，深度不可控，怎么写安全？**

  改成循环加显式栈：

  `const stack = [root]; while (stack.length) { const n = stack.pop(); stack.push(...n.children) }`

  数组放在堆里，几十万层也不会爆调用栈。

- **把同步递归改成 `setTimeout` 里递归调用，能解决栈溢出吗？**

  能解决栈的问题，每次回调都是在新的宏任务里从空栈开始。但终止条件缺失的话，就从栈溢出变成了无限排队的死循环，`CPU` 照样被吃满，先把终止条件补对。

- **`ES6` 的尾调用优化不是能解决递归爆栈吗？**

  规范里是有，但只有 `Safari` 实现了，`Chrome` 和 `Node` 都没实现，`V8` 试过之后撤掉了。所以写成尾递归在 `Chrome` 里照样爆，别指望它。

## 什么是函数调用

- 函数调用 = 函数名 + `()`，比如 `add()`
- 调用前已经有全局执行上下文，全局变量和函数声明都在里面
- 执行到 `add()`：从全局上下文取出函数代码 → 编译 → 创建 `add` 的执行上下文 → 执行
- 这时全局上下文和函数上下文同时存在，嵌套调用会越堆越多
- 每次调用都是一个新的执行上下文，调两次就建两次

**函数调用就是执行到 `add()` 时，引擎为这次调用单独建一个执行上下文，然后跑函数体。**

```js
var a = 2
function add() { var b = 10; return a + b }
add() // 12
```

执行到 `add()` 之前，全局执行上下文里已经有 `a` 和 `add`。调用时引擎从全局上下文取出 `add` 的代码，编译它，建好 `add` 自己的执行上下文（里面有 `b`），再执行。这时候有两个上下文同时存在，`add` 里要是再调别的函数还会继续加。要管好这些上下文的先后顺序，就引出了调用栈。

```mermaid
sequenceDiagram
    autonumber
    participant E as JS引擎
    participant St as 调用栈
    participant G as 全局上下文
    participant F as add上下文
    E->>G: 编译全局代码，登记 a 和 add
    E->>St: 全局上下文入栈
    E->>G: 执行 a = 2
    E->>G: 遇到 add()，取出函数代码
    E->>F: 编译 add，创建执行上下文
    E->>St: add 上下文入栈
    F->>G: 读取 a，沿作用域链找到 2
    F-->>E: return 12
    E->>St: add 上下文出栈
    opt 递归没有终止条件
        St--xE: 只进不出，栈溢出 RangeError
    end
```

函数调用就是运行一个函数，具体使用方式是使用函数名称跟着一对小括号。下面我们看个简单的示例代码

```js
var a = 2
function add(){
var b = 10
return  a+b
}
add()
```

这段代码很简单，先是创建了一个add函数，接着在代码的最下面又调用了该函数。

那么下面我们就利用这段简单的代码来解释下函数调用的过程。

在执行到函数add()之前，JavaScript引擎会为上面这段代码创建全局执行上下文，包含了声明的函数和变量，你可以参考下图：

![](https://s.poetries.top/images/202203011702153.png)

从图中可以看出，代码中全局变量和函数都保存在全局上下文的变量环境中。

执行上下文准备好之后，便开始执行全局代码，当执行到add这儿时，JavaScript判断这是一个函数调用，那么将执行以下操作：

- 首先，从全局执行上下文中，取出add函数代码。
- 其次，对add函数的这段代码进行编译，并创建该函数的执行上下文和可执行代码。
- 最后，执行代码，输出结果。

完整流程你可以参考下图：

![](https://s.poetries.top/images/202203011702783.png)

就这样，当执行到add函数的时候，我们就有了两个执行上下文了——全局执行上下文和add函数的执行上下文。

也就是说在执行JavaScript时，可能会存在多个执行上下文，那么JavaScript引擎是如何管理这些执行上下文的呢？

答案是通过一种叫**栈的数据结构来管理的**。那什么是栈呢？它又是如何管理这些执行上下文呢？

- **`add()` 里读了全局的 `a`，同事说调用期间只有全局执行上下文，哪里不对？**

  调用期间有两个上下文：全局的（有 `a`、`add`）和 `add` 自己的（有 `b`）。`a` 是顺着作用域链从全局找到的，不代表函数上下文不存在。

- **`add` 声明了但一直没被调用，埋点却记成「已执行」，怎么改？**

  声明只是把函数存进了全局上下文，函数体一行都没跑。埋点要放在函数体里或者实际调用的地方。

- **`addAll()` 里连续调两次 `add()`，能不能共用一个执行上下文省点开销？**

  不能。每次调用都是独立的执行上下文，参数、局部变量互不影响，第一次的 `b` 跟第二次的 `b` 是两份。调完一个弹出一个，栈深度不会累积。

- **线上只有 `add()` 里报错，全局的 `a` 已经确认是 `2`，还要查什么？**

  查这次调用自己的局部状态：参数对不对、函数里的局部变量有没有被意外改了。`DevTools` 断在函数里，`Scope` 面板会分开显示 `Local` 和 `Global`，一眼就能对上。

- **多个执行上下文为什么要用栈来管，不能用个数组随便存吗？**

  因为调用者要等被调用者返回才能继续，后进去的一定先出来，这就是后进先出。无序存放没法知道当前该执行谁、返回后回到哪。

## 什么是栈

- 栈：只能在一端（栈顶）进出，后进先出（`LIFO`）
- 入栈 `push`、出栈 `pop`，空栈再 `pop` 是下溢，满了再 `push` 是上溢
- 适合「嵌套关系、要按相反顺序结束」的场景：函数调用、括号匹配、撤销操作、`DFS`
- 数组只是实现载体，允许从中间删元素就不是栈了
- 要「先来先处理」用队列，别拿栈从底部取

**栈就像一条一头堵死的单车道，后开进去的车得先倒出来，这就是后进先出。** 依次压入 `A`、`B`、`C`，只能先拿到 `C`，`C` 出去了 `B` 才露出来。这个特性天生适合处理嵌套关系，最典型的就是函数调用和括号匹配：

```js
function isValid(s) {
  const map = { ')': '(', ']': '[', '}': '{' }, stack = []
  for (const c of s) {
    if ('([{'.includes(c)) stack.push(c)
    else if (stack.pop() !== map[c]) return false
  }
  return stack.length === 0
}
isValid('{[()]}') // true
isValid('([)]')   // false
```

关于栈，你可以结合这么一个贴切的例子来理解，一条单车道的单行线，一端被堵住了，而另一端入口处没有任何提示信息，堵住之后就只能后进去的车子先出来，这时这个堵住的单行线就可以被看作是一个栈容器，车子开进单行线的操作叫做入栈，车子倒出去的操作叫做出栈。

在车流量较大的场景中，就会发生反复的入栈、栈满、出栈、空栈和再次入栈，一直循环。

所以，栈就是类似于一端被堵住的单行线，车子类似于栈中的元素，栈中的元素满足后进先出的特点。你可以参看下图：

![](https://s.poetries.top/images/202203011702832.png)

**原理拆解：** 栈的关键不在于具体容器形状，而在于访问规则：只能在栈顶执行插入和删除。假设依次压入 `A`、`B`、`C`，此时可直接取出的只能是 `C`；只有 `C` 出栈后，`B` 才会成为新的栈顶。因此，入栈顺序与出栈顺序天然相反，这种后进先出的性质能够保存尚未结束的嵌套关系。

**具体例子：** 编辑器的括号匹配可以利用栈处理。扫描到左括号时将其压栈，扫描到右括号时检查栈顶是否为对应的左括号，匹配成功后再出栈。表达式扫描结束时，如果栈为空，说明所有嵌套都已经正确闭合；如果仍有元素，则存在未闭合的左括号。

**边界与反例：** 栈并不等于数组，数组只是栈的一种实现载体。若允许从中间随机删除元素，数据结构就不再遵守严格的栈约束。对空栈执行出栈属于下溢；对固定容量栈继续入栈属于上溢。动态数组实现虽然可以扩容，但仍会受到进程内存等资源上限约束。

**工程验证：** 调试栈结构时，应同时观察入栈后的栈顶、出栈返回值和当前长度。连续压入多个带编号的值，再逐个弹出，若结果恰好为编号的逆序，就验证了后进先出规则；若业务代码需要取得最早进入的元素，则更适合使用队列，而不是绕过栈顶直接访问栈底。

- **有人实现历史记录栈时允许直接删中间的 `B`，还算栈吗？**

  不算了。栈的定义就是只能动栈顶，能从中间删就是个普通列表。用数组实现可以，但对外只暴露 `push` / `pop` / `peek`。

- **括号匹配用栈怎么做？**

  遇到左括号压栈，遇到右括号就弹出栈顶看是不是配对的。中途栈空或者不配对就是错，扫完栈里还有东西说明有没闭合的。要报位置的话，压栈时把下标一起压进去。

- **任务要求先来的先处理，有人拿数组栈从栈底取，有问题吗？**

  这就是队列的需求，应该直接用队列。而且 `JS` 数组 `shift()` 是 `O(n)`，数据量大了会慢，可以用双指针或者链表实现队列。

- **用 `JS` 数组实现的栈不是能自动扩容吗，怎么还会溢出？**

  数组扩容也受内存限制，只 `push` 不 `pop` 迟早吃满内存。另外别搞混：「栈溢出」一般说的是引擎的调用栈，它的大小是固定的，比堆小得多，所以深递归爆的是它，不是你的数组。

- **撤销功能要「撤销上一步」，偶尔又要按编号看历史，纯栈够吗？**

  不够。撤销那条路径用栈，查历史另外维护一个数组或者 `Map` 做索引。常见做法是两个栈：撤销栈和重做栈，撤销时从一个弹出压到另一个。

## 什么是JavaScript的调用栈

---

> 以上是免费部分。完整内容需要「前端进阶之旅」会员，原文：https://feinterview.poetries.top/docs/fe-base-docs/browser/part2/08-%E8%B0%83%E7%94%A8%E6%A0%88%EF%BC%9A%E4%B8%BA%E4%BB%80%E4%B9%88JavaScript%E4%BB%A3%E7%A0%81%E4%BC%9A%E5%87%BA%E7%8E%B0%E6%A0%88%E6%BA%A2%E5%87%BA
