# 栈空间和堆空间：数据是如何存储的|浏览器篇

> 本文深入解析JavaScript中栈空间和堆空间的区别，讲解数据在内存中的存储方式，帮助前端开发者理解基本类型与引用类型的内存分配、变量赋值和数据变化原理，为提升代码性能和避免常见内存问题提供理论基础。

- 原文：https://feinterview.poetries.top/docs/fe-base-docs/browser/part3/12-%E6%A0%88%E7%A9%BA%E9%97%B4%E5%92%8C%E5%A0%86%E7%A9%BA%E9%97%B4%EF%BC%9A%E6%95%B0%E6%8D%AE%E6%98%AF%E5%A6%82%E4%BD%95%E5%AD%98%E5%82%A8%E7%9A%84
- 来源：前端进阶之旅（feinterview.poetries.top）
- 更新：2026.10.03
- 可见范围：免费部分

---

## 栈空间和堆空间：数据是如何存储的

- `JS` 自动管理内存，但不懂内存模型，赋值联动、内存泄漏都解释不清
- 常用模型：执行上下文和小的原始值放栈，对象、数组、函数放堆，变量里存引用
- 原始值赋值 = 复制一份值；对象赋值 = 复制引用，改属性两边都能看到
- 这是教学模型，不是规范：`V8` 里字符串、非小整数都在堆上，闭包变量也会进堆
- 这一系列分三篇：数据怎么存、垃圾怎么回收、`V8` 怎么执行代码

**`JS` 不用手动管内存，但你得知道数据大致存在哪，不然赋值后数据「莫名其妙跟着变」这种问题根本解释不清。** 常用的模型是栈和堆两块：调用栈放执行上下文，对象、数组这类大小不定、可能共享的数据放堆，变量里存的是指向堆的引用。所以 `const b = a` 之后改 `b.name`，`a.name` 也变了。不过要说清楚，这只是方便理解的模型，规范没规定物理布局，`V8` 里字符串其实也在堆上，面试时我会顺带补一句，别说得太绝对。

对于前端开发者来说，JavaScript 的内存机制是一个不被经常提及的概念 ，因此很容易被忽视。特别是一些非计算机专业的同学，对内存机制可能没有非常清晰的认识，甚至有些同学根本就不知道 JavaScript 的内存机制是什么

但是如果你想成为行业专家，并打造高性能前端应用，那么你就必须要搞清楚JavaScript 的内存机制了。

其实，要搞清楚 JavaScript 的内存机制并不是一件很困难的事，在接下来的三篇文章（数据在内存中的存放、JavaScript 处理垃圾回收以及 V8 执行代码）中，我们将通过内存机制的介绍，循序渐进带你走进 JavaScript 内存的世界。

今天我们讲述第一部分的内容——JavaScript 中的数据是如何存储在内存中的。虽然 JavaScript 并不需要直接去管理内存，但是在实际项目中为了能避开一些不必要的坑，你还是需要了解数据在内存中的存储方式的

**原理拆解：** `JavaScript` 语言规范定义的是值、对象和赋值语义，并未强制引擎把某类数据物理存入栈或堆。工程上通常把执行上下文、局部变量等短生命周期信息概括为栈空间，把对象、数组、函数等可共享且大小动态变化的数据概括为堆空间。变量保存基本类型时，赋值获得独立的值；变量指向对象时，赋值复制的是同一对象的引用，因此通过任一引用修改属性，其他引用都能观察到变化。对象变量本身与对象内容应分开理解：前者可随调用帧管理，后者通常由引擎在堆中分配。

**最小验证：** 输入一个数字和一个对象，分别执行赋值与修改，用来验证基本类型的值复制和对象的引用共享。

```javascript
let scoreA = 10;
let scoreB = scoreA;
scoreB = 20;

const userA = { name: "Ada", skills: ["JavaScript"] };
const userB = userA;
userB.name = "Grace";
userB.skills.push("TypeScript");

const userC = { ...userA };
userC.name = "Lin";
userC.skills.push("CSS");

console.log(scoreA, scoreB);
console.log(userA.name, userB.name, userA === userB);
console.log(userA.skills);
console.log(userC.name, userC === userA);
```

数字部分预期输出 `10 20`，说明重新赋值 `scoreB` 不会改变 `scoreA`。`userA === userB` 为 `true`，且两者名称都变为 `Grace`。展开语法只创建浅拷贝，所以 `userC !== userA`，但嵌套的 `skills` 仍被共享，最终 `userA.skills` 也包含 `CSS`。

**边界与排查：** “基本类型一定在栈、对象一定在堆”只是便于推理的模型，字符串驻留、闭包捕获、逃逸分析和引擎优化都可能改变实际布局，不能据此判断精确内存位置。`const` 只禁止变量重新绑定，并不冻结对象；需要阻止顶层属性修改可使用 `Object.freeze`，但它同样不是递归冻结。排查意外联动时，应先检查 `===`、嵌套引用和浅拷贝边界；排查占用增长可使用浏览器开发者工具的 Heap Snapshot 对比分配与保留路径，但快照只能观察堆对象，不能直接证明某个值位于调用栈。

- **「原始类型一定在栈、对象一定在堆」，这个说法对吗？**

  作为理解赋值语义的模型可以，作为实现事实不对。`V8` 里只有小整数（`Smi`）直接存在值里，字符串、浮点数都是堆对象，被闭包捕获的变量也进堆。判断行为看值语义，别拿模型推内存地址。

- **`const draft = source` 改 `draft.name`，预览区 `source.name` 也变了，怎么改？**

  `draft === source` 是 `true`，同一个对象。要独立草稿就复制：只有一层用 `{ ...source }`，有嵌套用 `structuredClone(source)`，但它不能克隆函数和 `DOM` 节点。

- **表单加了嵌套的 `skills` 数组后，`{...source}` 复制的副本开始污染原数据，为什么？**

  展开语法是浅拷贝，只复制顶层，`skills` 还是同一个数组引用。要么单独 `skills: [...source.skills]`，要么整体 `structuredClone`。

- **用 `const` 声明对象，是不是就改不了了？**

  `const` 只锁变量不能重新赋值，对象内部照样能改。要锁属性用 `Object.freeze`，而且它只冻顶层，嵌套对象还能改。

## 让人疑惑的代码

- 第一段：原始值赋值复制值本身，`a = 2` 之后 `b` 还是 `1`
- 第二段：`b = a` 复制的是对象引用，改 `a.name`，`b` 也看到 `{name: "极客邦"}`
- 改属性（`a.name = ...`）≠ 换引用（`a = {...}`），后者不影响 `b`
- `===` 判断是不是同一个对象；展开语法、`Object.assign` 只是浅拷贝
- `JS` 里参数传递永远是值传递，对象场景传的值恰好是引用

**第一段打印 `2` 和 `1`，第二段 `a`、`b` 都打印 `{name: "极客邦"}`，区别在于赋值复制的是值还是引用。** 打个比方，原始值像复印了一张纸，你改原件复印件不变；对象像复制了一把钥匙，两把钥匙开的是同一个房间，谁进去改了家具另一个都能看到。但要分清改属性和换引用：`a.name = 'x'` 是进房间改东西，`b` 能看到；`a = { name: 'x' }` 是让 `a` 换了一把新钥匙，`b` 手里那把还是旧房间，完全不受影响。

首先，我们先看下面这两段代码：

```js
function foo(){
    var a = 1
    var b = a
    a = 2
    console.log(a)
    console.log(b)
}
foo()
```

```js
function foo(){
    var a = {name:" 极客时间 "}
    var b = a
    a.name = " 极客邦 "
    console.log(a)
    console.log(b)
}
foo()
```

若执行上述这两段代码，你知道它们输出的结果是什么吗？下面我们就来一个一个分析下。

执行第一段代码，打印出来 a 的值是 2，b 的值是 1，这没什么难以理解的。

接着，再执行第二段代码，你会发现，仅仅改变了 a 中 name 的属性值，但是最终 a 和 b 打印出来的值都是{name:"极客邦"}。这就和我们预期的不一致了，因为我们想改变的仅仅是 a 的内容，但 b 的内容也同时被改变了。

要彻底弄清楚这个问题，我们就得先从“JavaScript 是什么类型的语言”讲起。

**原理拆解：** 变量赋值复制的是“值”。原始类型的值就是数据本身，因此 `b = a` 后，`a` 与 `b` 各自保存独立的数值；随后执行 `a = 2`，只是让 `a` 绑定新值。对象变量中保存的值可理解为指向对象的引用，`b = a` 复制了该引用，所以两者能访问同一对象。`a.name = "极客邦"` 修改的是共享对象的属性，并没有改变 `a` 自身保存的引用。所谓“栈存原始值、堆存对象”是常用的实现模型，但 ECMAScript 规范并不要求引擎采用固定的栈、堆布局；判断代码行为应以值语义和对象身份为准。

**最小验证：** 输入包含原始值赋值、对象赋值和对象重新赋值，用来验证“修改共享对象”与“替换变量引用”是两种不同操作。

```js
function verify() {
  let a = 1;
  let b = a;
  a = 2;
  console.log(a, b); // 2 1

  let userA = { name: "极客时间" };
  let userB = userA;
  console.log(userA === userB); // true

  userA.name = "极客邦";
  console.log(userA.name, userB.name); // 极客邦 极客邦

  userA = { name: "新对象" };
  console.log(userA.name, userB.name); // 新对象 极客邦
  console.log(userA === userB); // false
}

verify();
```

关键行 `userA.name = ...` 沿引用修改原对象，因此 `userB` 可观察到变化；`userA = {...}` 则创建新对象并替换 `userA` 的引用，不会反向修改 `userB`。若第二组身份比较仍为 `true`，通常说明测试代码没有真正执行重新赋值。

**边界与排查：** 展开语法 `{...userA}`、`Object.assign({}, userA)` 只能完成浅复制：顶层属性可以独立修改，但嵌套对象仍可能共享。需要深复制且数据满足结构化克隆条件时，可使用现代浏览器提供的 `structuredClone`；函数、DOM 节点等值不能按普通结构化数据直接克隆。`const` 只禁止变量重新绑定，并不冻结对象属性；若要阻止顶层属性修改，可用 `Object.freeze`，但它同样不是递归深冻结。工程排查时可用 `===` 验证两个变量是否指向同一对象，并分别测试属性修改与变量重新赋值，避免把引用共享误判为赋值异常。

- **`let b = a; a = { name: '新对象' }` 之后 `b.name` 还是旧值，引用规则失效了？**

  没失效。`a = {...}` 是让 `a` 指向新对象，`b` 还指着原来那个。只有 `a.name = ...` 这种改属性的操作，`b` 才会看到。

- **订单页 `const backup = order` 做提交前备份，然后改了十几个字段，备份还有用吗？**

  没用，`backup === order`，改的是同一个对象。至少要 `structuredClone(order)`，嵌套结构简单的话展开语法也行，但要确认嵌套字段不会被改。

- **函数里改 `profile.age` 影响了外部，但 `profile = { age: 20 }` 没影响，怎么解释？**

  参数是值传递，传进来的值是一个引用。改属性是顺着引用改共享对象；重新赋值只是让形参指向新对象，调用方的变量不受影响。

- **`Object.freeze(user)` 之后 `user.profile.name` 还能改，冻结失败了吗？**

  没失败，`Object.freeze` 只冻结顶层属性，`profile` 这个引用不能换，但它指向的对象本身没被冻。要全冻得自己递归 `freeze`。

- **大表单要做撤销，每次修改都完整深拷贝一份，合适吗？**

  数据小没问题，数据大了内存和耗时都扛不住。更常见的是不可变更新：只复制改动路径上的对象，没改的子树共享引用，`Immer` 就是这么干的。

## JavaScript 是什么类型的语言

- 两个独立维度：类型什么时候确定（静态 / 动态），能不能偷偷转换（强 / 弱）
- 静态：使用前就确定类型，比如 `C` 的 `int a = 1`；动态：运行时才检查，`JS` 声明不用写类型
- 弱类型 = 支持隐式类型转换，`C` 和 `JS` 都算；`Python` 是动态 + 强类型
- `JS` = 动态 + 弱类型，`1 + '2'` 得 `'12'`
- 业务里别依赖隐式转换，数据入口就显式转成对的类型

**`JS` 是动态、弱类型语言，这是两个不同维度，别混在一起说。** 动态还是静态，看类型是什么时候确定的：`C` 要先写 `int`、`char*`，`JS` 一个 `let` 什么都能装。强还是弱，看能不能偷偷转换类型：`C` 能把 `int` 赋给 `bool`，`JS` 里 `1 + '2'` 直接得 `'12'`，所以都是弱类型。反例是 `Python`，它是动态的，但 `1 + '2'` 直接报错，属于强类型。写业务代码时，我会在数据入口用 `Number()` 显式转好，而不是指望隐式转换。

每种编程语言都具有内建的数据类型，但它们的数据类型常有不同之处，使用方式也很不一样，比如 C 语言在定义变量之前，就需要确定变量的类型，你可以看下面这段 C 代码：

```c
int main()
{
   int a = 1;
   char* b = " 极客时间 ";
   bool c = true;
   return 0;
}
```

上述代码声明变量的特点是：在声明变量之前需要先定义变量类型。我们把这种在使用之前就需要确认其变量数据类型的称为静态语言。

相反地，我们把在运行过程中需要检查数据类型的语言称为动态语言。比如我们所讲的 JavaScript 就是动态语言，因为在声明变量之前并不需要确认其数据类型。

虽然 C 语言是静态，但是在 C 语言中，我们可以把其他类型数据赋予给一个声明好的变量，如：

```
c = a
```

前面代码中，我们把 int 型的变量 a 赋值给了 bool 型的变量 c，这段代码也是可以编译执行的，因为在赋值过程中，C 编译器会把 int 型的变量悄悄转换为 bool 型的变量，我们通常把这种偷偷转换的操作称为隐式类型转换。而支持隐式类型转换的语言称为弱类型语言，不支持隐式类型转换的语言称为强类型语言。在这点上，C 和 JavaScript 都是弱类型语言。

对于各种语言的类型，你可以参考下图

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

- **变量能从数字改成字符串，所以动态语言一定是弱类型，对吗？**

  不对。`Python` 变量也能随便换类型，但 `1 + '2'` 直接 `TypeError`，它是动态 + 强类型。能不能换类型和能不能偷偷转换是两回事。

- **结算页 `price + fee`，`price` 是输入框里的字符串，算出 `'1005'`，算谁的锅？**

  隐式转换的锅，`+` 遇到字符串就变成拼接。输入框的值永远是字符串，取值时就 `Number(input.value)`，再判一下 `Number.isNaN`。

---

> 以上是免费部分。完整内容需要「前端进阶之旅」会员，原文：https://feinterview.poetries.top/docs/fe-base-docs/browser/part3/12-%E6%A0%88%E7%A9%BA%E9%97%B4%E5%92%8C%E5%A0%86%E7%A9%BA%E9%97%B4%EF%BC%9A%E6%95%B0%E6%8D%AE%E6%98%AF%E5%A6%82%E4%BD%95%E5%AD%98%E5%82%A8%E7%9A%84
