一个数据看板页面,用户会挂着看一整天。有客户反馈说用久了电脑发烫、页面越来越慢,关掉标签页才恢复。开发同学打开任务管理器盯了一会儿,发现这个标签页的内存曲线一路往上走,刷新一下又掉回原点。

刷新能回落,说明不是浏览器漏了内存,而是页面自己一直抓着东西不放。这类问题的排查,靠读代码往往看不出来,得先知道引擎怎么判断一个对象「还有人用」、怎么在合适的时机把它收走。知道了规则,才知道该去堆快照里找什么。

这篇讲三件事:源码怎么变成能执行的东西、为什么同样的逻辑换个写法会快很多、内存是什么时候被回收的。前面两件是速度,后面一件是稳定性,都是日常开发里绕不开的底层机制。需要说明的是,具体实现以 V8 为主,其他引擎的分层和命名不一样,别把这里的细节当成所有浏览器的通用结论。

先看内存:从现象到证据

先别猜。打开 DevTools 的 Memory 面板,做两次堆快照:一次在刚进入页面时,一次在反复切换页面、操作十分钟之后。用 Comparison 视图对比两份快照,看哪些类型的对象数量明显增加。

我的假设有三个,逐个验证:

  • DOM 节点没被移除。 在 Elements 面板里看节点总数,或者在控制台数 document.querySelectorAll("*").length。如果数量稳定,排除。
  • 定时器或事件监听没清理。 在代码里给 setInterval 和 addEventListener 各加一个计数器,进出页面时打印。如果只增不减,基本锁定。
  • JS 对象被缓存或闭包持有。 看快照里增长最多的构造函数,点进去看 Retaining Path,也就是「谁引用着它」。如果路径指向一个模块级数组或者某个闭包,就找到源头了。

第三个假设往往是最终答案,但前两个要先排掉,否则你会在错误的方向上翻代码。堆快照的 Comparison 视图里还有个 Detached 筛选,专门找「已经从 DOM 树上移除、但仍被 JS 引用」的节点,这是前端最典型的一类泄漏。

堆快照本身会暂停页面并占用大量内存。别在用户正在用的生产页面上频繁采样,也别拿一个已经卡死的页面反复拍快照。排查时用开发环境或者可控的复现环境。

源码到字节码

浏览器拿到 JS 源码,第一步不是执行,而是解析。解析器把文本变成抽象语法树,再生成字节码。V8 的解释器叫 Ignition,它执行的就是这份字节码,而不是直接跑源码。

V8 里一段代码的生命周期
解析源码变成 AST,函数体可以延迟解析
字节码生成中间表示,交给解释器执行
收集反馈记录参数类型、属性访问命中了哪些形状
优化编译热点函数交给更高一层的编译器生成机器码
去优化假设被打破时退回解释执行,重新积累反馈

解析阶段有个优化叫延迟解析:函数体在第一次被调用之前,只做粗略的预解析,不生成完整 AST。页面里定义了几百个函数但只用其中几个时,这个策略能省下不少启动时间。代价是第一次调用那个函数时会多一次解析开销,所以「首屏卡一下」有时候来自某个大函数被第一次执行。

字节码相比机器码更紧凑,启动快,但它终究是解释执行。真正让 JS 跑得快的是后面那一步:引擎一边执行,一边记录「这个加法两边都是数字」「这个属性访问每次都命中同一个形状」,等函数热起来之后,再根据这些反馈生成高度特化的机器码。

对象形状与内联缓存

JS 的对象是动态的,随时能加属性。如果每次访问属性都要做一次哈希查找,性能会很差。引擎的做法是给对象维护一个「形状」,也叫隐藏类:属性名和它们在内存里的偏移量固定下来,访问 obj.x 就变成「形状匹配 + 固定偏移读取」。

// 同样的属性,不同顺序,会形成不同的形状
const a = { x: 1, y: 2 };
const b = { y: 2, x: 1 };

// 先创建空对象再逐个补属性,也会经历多次形状转换
const c = {};
c.x = 1;
c.y = 2;

形状一致的对象,访问走同一套偏移规则。引擎还会在调用点缓存「上次这个属性访问命中了哪个形状」,这叫内联缓存。只命中一种形状是单态,最快;命中两三种是多态,稍慢;再多就退化成通用查找。

这解释了几个流传很广的写法建议背后的原因,而不是玄学:

  • 对象尽量在创建时就把字段写全,别先建空对象再一次次补;
  • 同一类数据用同样的字段顺序,别在不同分支里换着顺序赋值;
  • delete obj.prop 会让对象退化成字典模式,后续访问变慢,用赋 undefined 或者重建对象代替;
  • 数组不要混装不同类型,混入字符串或者制造空洞,会让元素种类降级,访问走更慢的路径。

这些在真正的热点代码里才有意义。一个只跑几十次的函数,形状怎么变都无所谓。把整个项目都按这套规则改写,收益可能还抵不上可读性的损失。

JIT 分层与去优化

「JIT」不是「一次编译成机器码」这么简单,现代引擎是分层的。以 V8 为例,大致有这么几层:解释器负责冷代码;基线编译器把字节码快速翻译成还不错的机器码;更高一层的优化编译器根据类型反馈生成非常特化的代码。不同版本里中间层的名字和数量有变化,这里是结构,不是固定名单。

优化编译器会做出很强的假设:这个加法两边一直是数字、这个属性访问一直是同一个形状、这个函数没有被重新定义。有了这些假设,它才能省掉类型检查、直接做整数加法。问题是 JS 允许你随时打破假设:

function add(a, b) {
  return a + b;
}

for (let i = 0; i < 100000; i++) add(i, i);   // 一直是数字,可能被优化
add("1", "2");                                // 突然变成字符串拼接

当假设被打破,引擎会做去优化:丢掉那份特化机器码,退回字节码继续执行,重新收集反馈。等新反馈稳定了,可能再优化一次。这个过程对单次调用影响不大,但如果你的代码每隔几次就换一种参数类型,函数会在「优化—去优化」之间反复横跳,性能比一直解释执行还差。

所以「这个函数有时传数字有时传字符串」不只是类型洁癖问题,它真的会让引擎白忙。把参数类型稳定下来,比任何写法技巧都有效。

也要知道这套机制的边界:引擎不会因为你的代码「看起来丑」而变慢,它只对实际观察到的类型和形状做反应。微基准测出来的「A 写法比 B 快三倍」,很可能只是测试环境里 JIT 更容易优化 A,换到真实调用栈里就消失了。

内存:栈、堆和闭包

函数调用时的局部变量、参数放在栈上,函数返回栈帧就没了。对象、数组、闭包环境这些活得可能比函数调用更久的东西放在堆上,由垃圾回收器管理。

闭包是关键。一个内部函数引用了外部函数的变量,即使外部函数已经返回,那块环境也不能回收,因为内部函数还可能被调用。前端最常见的内存问题,都是闭包无意中把一大块数据带走了:

function createHandler() {
  const hugeData = fetchHugeData();      // 几百条记录
  return function onClick() {
    console.log(hugeData.length);        // 只用了 length
  };
}

只要这个 onClick 还挂在某个按钮上,hugeData 整个数组就活着。现代引擎会做一些优化,只保留真正被内部函数用到的变量,但具体能优化到什么程度依赖实现,别把它当成保证。真要只留一个数字,就在创建闭包之前把它取出来,别让闭包直接引用大对象。

分代回收怎么工作

大多数对象活得很短:创建、用完、马上变成垃圾。所以回收器把堆分成新生代和老生代,用不同策略处理。

新生代新对象先放这里,空间小、回收频繁。回收时把还活着的对象复制到另一半空间,然后整块清掉旧的一半,速度很快。
老生代活过几轮回收的对象被晋升到这里,空间大、回收频率低。回收要做标记和整理,成本更高,但可以增量和并发地做,减少停顿。
可达性判断从根对象(全局对象、当前调用栈、活跃的闭包等)出发,能走到的对象都算活着,走不到的就是垃圾。循环引用不会导致泄漏,只要没有根能到达它。

「从根出发能不能走到」这条规则,决定了什么算泄漏:不是「没人引用」,而是「从根还有路径能到达」。一个对象被全局数组、未清理的监听器、还在跑的定时器、某个闭包、甚至一个 Promise 的回调链引用着,它就还可达,回收器就不会动它。

垃圾回收不是即时的。你可能删掉了引用,但回收要等到合适的时机才发生,所以任务管理器里的内存不会立刻下降。这不代表泄漏,只能通过快照对比看「该回收的对象是否仍然可达」。

需要在长生命周期里关联额外数据时,用 WeakMap:它的键是弱引用,键对象被回收后,对应的值也会失去引用。ES2021 之后还有 WeakRef 和 FinalizationRegistry,但它们的行为依赖回收时机,不适合写业务逻辑,只适合做缓存或清理的兜底。

前端最常见的几类泄漏

排查时按这个顺序看,命中率最高:

来源为什么回收不掉怎么确认
模块级缓存只增不减模块作用域长期存在,缓存里的对象一直可达看快照里该构造函数实例数是否随操作单调增长
事件监听没移除监听器引用着回调,回调的闭包引用着组件状态和 DOM打印监听器计数;快照里看 Detached DOM 的 Retaining Path
定时器没清定时器持有回调,回调持有闭包在 setInterval 外层计数,进出页面时对比
订阅没取消被订阅方持有回调,生命周期比组件长看订阅数量;用框架的清理钩子确认是否执行
全局变量挂大对象全局对象是根,挂上去就一直可达在控制台扫 window 上的自定义属性
Promise 链长期挂起未结束的异步操作引用着回调里的数据看未决 Promise 数量;检查请求是否有超时和取消
Worker 持有数据Worker 有独立堆,主线程释放不代表 Worker 释放在 Worker 里打印内存;关闭不再需要的 Worker

还有一类不算泄漏,但很像:内存确实被缓存占着,只是缓存有上限、会淘汰,曲线呈锯齿状而不是一直上升。区分方法是观察足够长的时间,看它是否在某个水平附近波动。真正的泄漏,是只涨不跌。

现象、机制、怎么自己验证

现象真实机制怎么验证
页面用久了内存只涨不跌,刷新就恢复 对象仍从根可达,回收器无法回收 两次堆快照做 Comparison,沿 Retaining Path 找到持有者
内存没涨,但操作越来越慢 可能是频繁回收、长任务或去优化,不是泄漏 Performance 面板看 GC 事件和长任务,区分是内存问题还是计算问题
同一个函数有时快、有时慢 类型反馈被打破,优化代码被丢弃,退回解释执行 Node 里用 --trace-deopt 跑一遍,读去优化原因
频繁增删属性的对象越来越慢 delete 让属性存储退化为字典模式,形状不再稳定 对比 delete 与赋 undefined 的循环耗时,观察差距
数组混入其他类型后遍历变慢 元素种类降级,访问从快速路径退到通用路径 构造两个数组分别测遍历耗时;在 Node 里用原生语法检查元素种类
关闭标签页后内存没有立刻归还 回收和进程回收都有延迟,内存由浏览器和系统统一管理 用浏览器任务管理器观察;手动触发 GC 后再看是否回落
微基准显示某写法快很多,线上没感觉 基准里的调用模式单一,JIT 容易优化;真实代码类型和形状更杂 把两种写法放回真实页面,用 Performance 面板比较,而不是只看循环计时

边界与代价

微优化基本不值得。 对象字段顺序、delete 的替代写法,这些在热点路径上才有一点点收益。业务代码里更常见的问题是「每次渲染都创建几万个临时对象」,这属于架构层面的分配量,不是靠调整属性顺序能救回来的。

微基准会骗人。 JIT 预热需要时间,测试循环可能被优化掉,常量可能被折叠,测量本身的 performance.now() 也有开销。一个只在基准里成立的结论,放到真实调用栈里经常消失。判断性能要看真实场景的火焰图和长任务,不要迷信孤立的小循环。

缓存是内存换时间。 无上限的缓存迟早变成泄漏;有上限的缓存要选淘汰策略,还要考虑命中率。每次加缓存前先问:这份数据能不能重新算出来,重算的代价有多大,用户实际会用到多少。答案不清楚就先别加。

GC 参数不归前端管。 浏览器里没有暴露调优入口,你无法控制什么时候回收、用多大堆。能做的是减少常驻对象、减少分配速率、及时释放引用。Node 里可以调堆大小,但那是服务端运维的范畴,而且调大堆只是把问题往后推。

引擎实现会变。 某个版本里有效的优化技巧,下个版本可能被更好的通用优化取代,也可能因为安全或内存权衡被削弱。把「V8 现在会这样做」当成规范写进团队文档,过两年就会误导人。要沉淀的是排查方法,不是具体版本的内部细节。

大多数内存问题来自依赖,不是你的代码。 图表库、编辑器、地图 SDK 常常自己维护大量缓存和监听。排查时先在堆快照里看增长最多的构造函数属于哪个包,再决定是升级、换库,还是只在必要时初始化。

今天就能动手的实验

  1. 写一个没有上限的 Map 缓存,循环往里塞对象,观察内存曲线;再换成 WeakMap,看对象是否还能被回收。
  2. 创建一个 DOM 节点、从页面上移除、但用 JS 变量引用着,拍快照后用 Detached 筛选找到它,再沿着引用链看是谁抓着。
  3. 写一个 setInterval 和一个事件监听,进出「页面」时不清理,用计数器确认它们一直在累积。
  4. 在 Node 里写一个参数类型会变化的函数,用 --trace-deopt 跑,读一读去优化的原因。
  5. 对比 delete obj.prop 和 obj.prop = undefined 在大量循环下的耗时;再把这个结论放回真实业务代码,看是否还有差别。

小结

源码先解析成字节码执行,热点函数再根据类型反馈编译成机器码。类型稳定、对象形状稳定,优化才站得住。
对象形状和内联缓存决定了属性访问的速度;delete、混装类型的数组、频繁变形的对象,都会让访问退回慢路径。
垃圾回收看的是「从根能不能走到」,不是「有没有人引用」。闭包、监听器、定时器、模块级缓存都是常见的持有者。
排查内存问题靠快照对比和引用链,不靠读代码猜。排查性能问题靠真实场景的长任务和火焰图,不靠孤立微基准。

下一篇讲浏览器架构。引擎只在渲染进程的主线程上占了其中一部分时间,同一时刻还有样式计算、布局、绘制、输入事件在排队。为什么一个标签页死循环不影响别的标签页,为什么主线程卡住时某些动画还能动,答案不在引擎里,在浏览器的进程与线程组织方式里。