很多年前做一个订单列表,每行右边有个「删除」按钮。当时是拼字符串生成表格,循环里绑事件,写成了这样:
var rows = [{ id: 1 }, { id: 2 }, { id: 3 }];
for (var i = 0; i < rows.length; i++) {
var btn = document.querySelectorAll(".del")[i];
btn.onclick = function () {
removeRow(rows[i].id); // 点哪一行,删的都是最后一行
};
}
点第一行的删除,删掉的是第三行。原因就是这篇要讲的闭包:三个函数共用同一个 i,等用户点的时候循环早结束了,i 停在 3,rows[3] 是 undefined,报错或者删错数据。
这篇讲什么:闭包这个词经常被讲得很玄,其实它描述的是一个很朴素的事实——函数会记住自己出生时周围有哪些变量,即使外面那层函数已经执行完了。这篇讲它怎么形成、在项目里到底用来干什么、循环里的问题怎么修,以及大家常说的「闭包会泄漏内存」到底是怎么回事。
闭包是什么:函数记得自己从哪来
先看一段最小的代码:
function outer() {
const message = "我是外层的变量";
function inner() {
console.log(message);
}
return inner;
}
const say = outer(); // outer 已经执行完了
say(); // "我是外层的变量"
outer() 执行结束后,按常理它的局部变量 message 应该被回收,但它没有。因为 inner 这个函数被返回出去了,而 inner 内部用到了 message,引擎必须把 message 留着,否则 say() 执行时找不到。
这就是闭包:一个函数,加上它能访问到的外层变量,打包在一起。函数被带到哪里,那包变量就跟到哪里。它不是某种特殊语法,你只要写了嵌套函数并且内层引用了外层变量,闭包就已经产生了。平时写回调、写事件处理,闭上眼都在用。
形成闭包需要三个条件同时满足:函数嵌套、内层函数引用了外层的变量、内层函数被带到了外层作用域之外(返回、赋值给全局、当回调注册)。只嵌套不引用,或者引用完了就地执行完,都不会留下什么。
两个容易混的点。第一,闭包捕获的是变量本身,不是绑定时那一刻的值的拷贝:
function outer() {
let n = 1;
const read = () => n; // 捕获的是 n 这个绑定
n = 2;
return read;
}
console.log(outer()()); // 2,不是 1
第二,外层函数每调用一次,就产生一套新的变量和新的闭包。两个计数器互不干扰:
function createCounter() {
let count = 0;
return () => ++count;
}
const a = createCounter();
const b = createCounter();
a(); // 1
a(); // 2
b(); // 1
console.log(a()); // 3
这两点合起来,就是循环那个 bug 的全部原因:三个回调捕获的是同一个 i,而且它们看到的是循环结束时 i 的值,不是绑定时那一刻的值。
循环里为什么共享,let 又怎么修好的
回到开头那个删除按钮。用 var 时,整个函数(或全局)只有一个 i,三个点击回调的闭包里存的是同一个变量的引用。循环结束后 i 变成 3,所以三个回调读到的都是 3。
把 var 换成 let 就好了:
for (let i = 0; i < rows.length; i++) {
document.querySelectorAll(".del")[i].onclick = function () {
removeRow(rows[i].id); // 现在点哪行删哪行
};
}
规范对 for + let 做了特殊处理:每一轮循环都会创建一个新的 i 绑定,三个回调各自记住自己那一轮的 i。这也是第一篇里「三个定时器都打印 3」那个例子的解法。
如果不方便改循环变量(比如老代码里是 var),可以再造一层函数,把当前值「锁」进去:
function bindDelete(id) {
return function () {
removeRow(id); // 参数 id 是每次调用时的新变量
};
}
for (var i = 0; i < rows.length; i++) {
document.querySelectorAll(".del")[i].onclick = bindDelete(rows[i].id);
}
这两种写法本质一样:让每个回调拥有一份自己的变量。第一种靠语言机制,第二种靠函数调用时新建作用域。项目里优先用 let,少写一层。
再补几个细节。for 加 let 之所以能修好,是规范专门为它开了口子:每一轮循环创建一个新的绑定,上一轮的值复制进去。所以三个定时器打印的是 0、1、2,而不是三个 3:
for (let i = 0; i < 3; i++) {
setTimeout(() => console.log(i), 0);
}
// 0
// 1
// 2
forEach 和 map 的回调天然就是每项一次调用、一个作用域,不会碰到这个问题。麻烦的是 while 循环:它没有 let 版本,只能在外面包一层函数,或者把当前的 id 提前写进元素:btn.dataset.id = rows[i].id,回调里读 this.dataset.id。
列表超过几百行时,逐个绑监听本身就不划算,改用事件委托:外层容器绑一个监听,用 event.target.closest(".del") 找到具体行。既没有几千个闭包,也不用担心新增行忘了绑。写法在事件模型那篇。
项目里闭包到底拿来干什么
面试常问「闭包有什么用」,实际项目里就三个高频用途:保存状态、延迟执行、制造私有变量。
防抖:把定时器藏在闭包里
function debounce(fn, delay = 300) {
let timer = null; // 这个变量被下面的函数记住了
return function (...args) {
clearTimeout(timer);
timer = setTimeout(() => fn(...args), delay);
};
}
const onSearch = debounce((keyword) => {
console.log("发请求搜索:" + keyword);
}, 300);
onSearch("a");
onSearch("ab");
onSearch("abc");
// 连续快速输入,只有最后一次会在 300ms 后打印:
// 发请求搜索:abc
timer 不能放在外面,否则多个防抖函数会互相清除对方的定时器;也不能放在返回的函数里面,那样每次调用都是新的,永远清不掉上一次。闭包刚好提供了「一份独立、又能在多次调用之间共享」的存储。
另一个常见的坑:timer 被闭包一直持有着,如果你在组件卸载时不清最后一次定时器,回调还会执行,去操作已经销毁的 DOM。所以防抖函数通常会再返回一个 cancel 方法,卸载时调用。
function debounce(fn, delay = 300) {
let timer = null;
function debounced(...args) {
clearTimeout(timer);
timer = setTimeout(() => fn.apply(this, args), delay);
}
debounced.cancel = () => {
clearTimeout(timer);
timer = null;
};
return debounced;
}
里面用的是普通函数加 fn.apply(this, args),这样调用时的 this 能传给真正的回调;如果 debounced 写成箭头函数,this 就固定在定义处了。
防抖能减少请求量,但减少多少取决于输入方式。搜索框逐字输入「华为手机」,共 5 次输入事件,不防抖就是 5 个请求,300ms 防抖之后通常是 1 个。可如果是扫码枪或者粘贴,只触发一次输入,防抖一点用都没有。
它解决不了的还有乱序。先输入「A」,请求走了 800ms;紧接着输入「AB」,请求只走 120ms。AB 的结果先回来,A 的结果后到,把列表覆盖成了 A 的内容。用户看到的是「搜 AB 却出了 A 的结果」。防抖只能少发请求,保证不了响应顺序,这个得靠请求序号或 AbortController——后面的完整场景会写。
私有状态:外面只能通过方法改
function createCounter() {
let count = 0; // 外部拿不到,也改不了
return {
inc() { return ++count; },
reset() { count = 0; },
get() { return count; }
};
}
const counter = createCounter();
counter.inc(); // 1
counter.inc(); // 2
counter.reset();
counter.get(); // 0
console.log(counter.count); // undefined
这是模块模式的老写法。现在有了 ES 模块和 class 的私有字段,这种做法少了很多,但写一些轻量工具(缓存、ID 生成器、节流器)时还是很好用。
代价要说清楚:每调用一次 createCounter,返回对象里的三个方法都是新建的函数对象,不是共享的。一万个实例就是三万个函数,再加每个实例自己那份 count。class 的私有字段能省掉这层:
class Counter {
#count = 0;
inc() { return ++this.#count; }
reset() { this.#count = 0; }
get() { return this.#count; }
}
const c = new Counter();
c.inc(); // 1
c.get(); // 1
// c.#count 在类外部是语法错误,读不到
# 开头是真的私有,外部读不到,方法挂在原型上共享。两者怎么选:需要 instanceof、需要序列化、实例上千,用 class;只是一个局部小工具、只有一两个方法,闭包更短。
缓存:只初始化一次
const getConfig = (function () {
let cached = null;
return function () {
if (cached) return cached;
console.log("真正加载配置");
cached = { apiBase: "/api", timeout: 3000 };
return cached;
};
})();
getConfig(); // 真正加载配置
getConfig(); // 直接返回缓存,不会再打印
这种「立即执行函数包一层」的写法在早期很流行,现在更多用模块顶层的变量实现,效果一样。要留心的是缓存没有过期机制,配置改了页面不刷新就一直用旧的。
真实项目里这个缓存通常还要加两件事。一是容量上限,不加的话用户搜了一千个不同的词,闭包里就存一千份结果,谁也不回收。二是 key 要带上租户和语言,不然 A 公司的数据会被 B 公司读到:
function createCache(limit = 200) {
const store = new Map();
return {
get(key) {
return store.get(key);
},
set(key, value) {
if (store.size >= limit) {
store.delete(store.keys().next().value); // 删最早进来的
}
store.set(key, value);
}
};
}
const cache = createCache();
cache.set("t1:zh:home", { title: "首页" });
console.log(cache.get("t1:zh:home")); // { title: "首页" }
这个「删最早进来的」不是严格的 LRU,它不看访问频率,只是先进先出。真要做淘汰策略,要么用现成的库,要么自己记录访问时间。用 Map 而不是普通对象,还顺带避开了键名撞上 __proto__ 的问题。
内存:闭包会不会泄漏
「闭包会导致内存泄漏」这个说法不准确。闭包持有变量是设计如此,只要这个函数还被使用,变量就该留着。真正的问题在于「不需要了却还被迫持有」。
下面几种情况才是要处理的:
| 情况 | 为什么会占着 | 怎么处理 |
|---|---|---|
| 定时器没清 | 回调闭包一直挂在定时器上,还引用着 DOM 或大数组 | 卸载时 clearTimeout / clearInterval |
| 事件监听没解绑 | 监听函数和它闭包里的数据都还在 | 保存函数引用,卸载时 removeEventListener |
| 全局数组不断 push | 闭包不是主因,是数据本身一直在长 | 设上限,或改用不需要的及时删除 |
| 缓存没有上限 | 每次调用都往闭包里的 Map 塞东西 | 用 Map 加容量上限,或用 WeakMap |
另外,现代引擎会做优化:闭包里没被用到的变量通常可以回收,不会因为「这个函数包了一整个作用域」就把所有东西都留着。eval 这种动态执行代码的写法会让引擎不敢优化,所以正式代码里基本不用它。
单页应用里最典型的一条路径:路由切换、组件卸载,但监听和解绑写漏了。监听函数连着它的闭包,闭包连着那棵已经不在页面上的 DOM 树。一次切换泄漏两三兆看着不多,用户来回切五十次就是一百多兆,标签页开始卡。内存面板里搜 Detached,能看到那些「已经移除但还被引用」的节点。
用对象当缓存键时还有一类隐形的持有:普通 Map 的键是强引用,只要 Map 还在,作为键的那个 DOM 节点或组件实例就一直活着。WeakMap 不会,键被回收时条目自动消失,适合存「元素到附加数据」的映射。
什么时候别用闭包
闭包不是越多越好,它有两个实实在在的代价:
状态藏起来了,不好查
数据在闭包里,控制台打印不到,调试器要一层层进函数作用域看。团队协作时,别人读代码不知道这个值什么时候变的。能用普通对象或模块变量表达的状态,就别刻意藏。
每个实例一份,数量大就有开销
给一万个列表项各生成一个闭包回调,内存和创建成本都上去了。这种情况更该用事件委托,一个监听处理所有行——具体写在事件模型那篇。
我的判断标准很朴素:这段状态需要在多次调用之间保留,又不想暴露给外部,就用闭包;如果它本来就应该被外部读写,老老实实放对象上,别为了「封装」增加理解成本。
完整场景走查:搜索联想框
需求不复杂:订单页顶部一个搜索框,输入时给联想词,要求四条——输入停顿 300ms 再发请求;同一关键词 5 分钟内走缓存;离开页面要能取消未完成的请求;旧请求的结果不能覆盖新结果。还有一个隐藏条件:客户页也有一个搜索框,两个框互不干扰。
第一版通常写成这样,能跑:
let timer = null;
const cache = {};
function onInput(kw) {
clearTimeout(timer);
timer = setTimeout(async () => {
if (cache[kw]) {
renderSuggest(cache[kw]);
return;
}
const res = await fetch("/api/orders/suggest?kw=" + kw);
const data = await res.json();
cache[kw] = data;
renderSuggest(data);
}, 300);
}
问题在「两个搜索框」和「用户不按套路操作」的时候才暴露:
timer和cache都在模块顶层。两个页面各自调用onInput,谁后输入谁就clearTimeout掉前一个的定时器。表现是:在订单页打字,客户页的联想不出来了。- 缓存没有上限也没有过期。客服把客户名从「张三」改成「张三丰」,五分钟后搜索框还在联想旧名字。用户输入上百个前缀,缓存就一直涨。
- 没有取消。输入完立刻切走页面,300ms 后定时器照样触发,请求发出去,回来时
renderSuggest去操作已经移除的 DOM,控制台报Cannot read properties of null。 - 顺序没保证。输入「A」后端走了 800ms,紧接着输入「AB」只走了 120ms,AB 先渲染,A 后到又覆盖回去。用户会觉得「越搜越错」。
- 缓存 key 只有关键词。同一套代码给多租户用,A 公司的联想词会出现在 B 公司的下拉里。
- 命中缓存也要等 300ms。明明本地就有结果,还要卡一下才显示,手感明显发钝。
改法是把状态收进一个工厂函数,每次创建一份独立的 timer、cache 和序号,再返回一个 destroy 让调用方在卸载时收尾:
function createSuggest({ input, render, delay = 300, ttl = 5 * 60 * 1000, limit = 100 }) {
let timer = null;
let seq = 0;
let controller = null;
const cache = new Map();
function readCache(key) {
const hit = cache.get(key);
if (!hit) return null;
if (Date.now() - hit.at > ttl) { // 过期就删掉
cache.delete(key);
return null;
}
return hit.data;
}
function writeCache(key, data) {
if (cache.size >= limit) {
cache.delete(cache.keys().next().value); // 先进先出
}
cache.set(key, { at: Date.now(), data });
}
async function run(keyword) {
const mine = seq;
controller = new AbortController();
try {
const res = await fetch(
"/api/orders/suggest?kw=" + encodeURIComponent(keyword),
{ signal: controller.signal }
);
const data = await res.json();
if (mine !== seq) return; // 这轮已经过期,结果丢掉
writeCache(keyword, data);
render(data);
} catch (err) {
if (err.name !== "AbortError") render([]);
}
}
function handleInput() {
const keyword = input.value.trim();
clearTimeout(timer);
seq += 1; // 让此前发出的请求全部作废
controller?.abort();
if (!keyword) {
render([]);
return;
}
const hit = readCache(keyword);
if (hit) { // 命中就立刻渲染,不等防抖
render(hit);
return;
}
timer = setTimeout(() => run(keyword), delay);
}
input.addEventListener("input", handleInput);
return {
destroy() {
clearTimeout(timer);
controller?.abort();
input.removeEventListener("input", handleInput);
}
};
}
const suggest = createSuggest({
input: document.querySelector("#order-search"),
render: renderSuggest
});
几个关键点对应着前面列的问题:createSuggest 每调用一次就是一套独立的闭包,两个搜索框各建一个,互不干扰;seq 在每次输入时自增,请求回来先比对序号,对不上就丢掉,乱序覆盖从根上没了;controller 既做取消,也让旧请求不必再等;缓存有过期和容量上限,key 在外面拼成 租户:关键词 再传进来;命中缓存直接渲染,只对未命中的请求做防抖。
最后补上卸载:
// 路由离开或组件销毁时
suggest.destroy();
按这个页面的量级(日均四万次输入事件)估算:不防抖不缓存,四万次全打到后端;加了防抖剩一万二左右,缓存命中三成多,回源大约八千次。请求量降下来的同时,用户感知的延迟也短了,因为命中的那些是同步渲染的。
还有一处必须提前想清楚:destroy 之后如果还有请求在飞,回调里 render 依然可能执行一次。所以 render 里最好自己判一下容器还在不在,别把「清理」全压在调用方身上。
错误现象对照
下面这些现象都来自真实工单,按「看到什么、实际是什么、先查哪里」整理。越是看着像框架 bug 的,越先看闭包捕获了什么。
| 现象 | 真实原因 | 第一步查什么 |
|---|---|---|
点哪一行的删除都删掉最后一行,或者报 Cannot read properties of undefined (reading 'id') |
var 声明的循环变量只有一个绑定,回调读的是循环结束后的值 |
看回调里引用的循环变量是 var 还是 let;把循环后的变量值打印出来 |
| 在订单页搜索,客户页的联想框不更新了 | 模块顶层的 timer 被多个实例共享,后一次 clearTimeout 取消了前一个 |
搜模块顶层有没有 let timer、let cache 这类可变变量 |
| 输入「AB」后列表先显示 AB,又闪回 A 的结果 | 响应乱序,旧请求后到并覆盖了新结果,防抖管不了顺序 | Network 面板对比请求的发起顺序和完成顺序;看代码里有没有请求序号或 abort |
| 每次输入都发请求,防抖像没生效 | 防抖函数被反复创建:在 input 事件里现场调用 debounce(fn),每次都是新闭包,timer 互相看不见 |
看 debounce 是创建一次存下来,还是每次事件都创建 |
切走页面后报 Cannot read properties of null (reading 'appendChild') |
定时器或请求回调在卸载之后执行,DOM 已经不在 | 查卸载逻辑里有没有 clearTimeout、abort、removeEventListener |
| 内存面板里 Detached DOM 只增不减,切页面越来越卡 | 监听没解绑,闭包一直持有已经移除的节点;或者 Map 用 DOM 当键 |
拍两次快照对比 Detached 数量;查解绑时传的函数是不是注册时那一个 |
最后一条最容易被忽略:removeEventListener 传一个现场新写的匿名函数,是解绑不掉的,这和闭包没关系,是引用比较。但它的后果和闭包泄漏长得一模一样,所以排查时两边都要看。
边界与代价
闭包是默认就该会用的工具,但它在几个地方会明显变贵,判断标准如下。
- 实例数量。一万行列表各绑一个闭包回调,就是一万个函数对象,再加每份捕获的环境,内存多出几兆,创建也要几十毫秒。超过五百行就考虑事件委托,一个监听顶掉一万个。
- 嵌套层数。工厂返回函数、函数里再返回函数,两层已经接近可读上限;三层以上调试时要展开多层作用域才能看到变量,建议拆成具名函数,别一路往里塞。
- 需要序列化或跨线程。闭包里的状态
JSON.stringify拿不到,也没法postMessage给 Worker。这种状态必须放到对象上。 - 需要外部读或写。为了「封装」把状态藏进闭包,结果是同事读代码看不到值、写测试只能走暴露的方法。本来就该公开的状态,放对象或 class 字段上。
- 生命周期特别长。全局 store、路由缓存这类活到页面关闭的单例,一旦在里面塞闭包,变量就跟着活到页面关闭。要么给明确的释放路径,要么别用。
- 性能。创建闭包本身很便宜,相对一次 DOM 操作可以忽略;真正的成本是延长对象生命周期、拖住不该留的内存。别为了省一个参数传递去造闭包。
一句话的判断:状态的生命周期等于一次函数调用,用局部变量;等于实例生命周期、且外部要读,用对象或 class;等于实例生命周期、且只给内部用,才用闭包。
小结
let 或再包一层函数,让每个回调拿到自己那份。下面几条今晚就能自己跑一遍,不需要业务代码:
- 写
function outer() { let n = 1; const read = () => n; n = 2; return read; },调outer()(),确认是 2 而不是 1。再把n = 2删掉,重新跑,理解「捕获的是变量」这句话。 - 把开头的删除按钮例子改成
let,用三个setTimeout打印 0、1、2;再改回var包一层bindDelete,确认结果一样。两种修法都亲手写一次。 - 写一个
debounce,连续调用五次,在真正的回调里累加一个计数,最后打印应该是 1;再调用一次cancel(),确认回调不再执行。 - 打开内存面板拍一次快照,反复切换页面十次,再拍一次,对比 Detached DOM 数量。涨了就去查监听和解绑。
- 搜项目里的模块顶层
let,逐个问自己:这个状态该不该收进工厂函数的闭包,还是本来就该由调用方持有。
下一篇讲对象与原型链,它们是顺着这篇往下走的。闭包解决的是「变量放在哪个作用域、活多久」,对象解决的是「一堆数据和方法怎么组织」;而原型链决定了你调用一个方法时,它到底是从实例自己身上找到的,还是从某个共享的原型上找到的。这篇里 createCounter 每实例一份方法的问题,下一篇会给出另一种答案:让方法只存一份,所有实例共用。读完回头看你写的计数器,会有更清楚的选择。