很多年前做一个订单列表,每行右边有个「删除」按钮。当时是拼字符串生成表格,循环里绑事件,写成了这样:

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);
}

问题在「两个搜索框」和「用户不按套路操作」的时候才暴露:

  1. timer 和 cache 都在模块顶层。两个页面各自调用 onInput,谁后输入谁就 clearTimeout 掉前一个的定时器。表现是:在订单页打字,客户页的联想不出来了。
  2. 缓存没有上限也没有过期。客服把客户名从「张三」改成「张三丰」,五分钟后搜索框还在联想旧名字。用户输入上百个前缀,缓存就一直涨。
  3. 没有取消。输入完立刻切走页面,300ms 后定时器照样触发,请求发出去,回来时 renderSuggest 去操作已经移除的 DOM,控制台报 Cannot read properties of null。
  4. 顺序没保证。输入「A」后端走了 800ms,紧接着输入「AB」只走了 120ms,AB 先渲染,A 后到又覆盖回去。用户会觉得「越搜越错」。
  5. 缓存 key 只有关键词。同一套代码给多租户用,A 公司的联想词会出现在 B 公司的下拉里。
  6. 命中缓存也要等 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 或再包一层函数,让每个回调拿到自己那份。
防抖、私有状态、一次性缓存是闭包的三个主战场;代价是状态不易观察、实例多了有开销。
闭包持有变量不是泄漏;定时器、监听、无上限缓存没清理才是。

下面几条今晚就能自己跑一遍,不需要业务代码:

  1. 写 function outer() { let n = 1; const read = () => n; n = 2; return read; },调 outer()(),确认是 2 而不是 1。再把 n = 2 删掉,重新跑,理解「捕获的是变量」这句话。
  2. 把开头的删除按钮例子改成 let,用三个 setTimeout 打印 0、1、2;再改回 var 包一层 bindDelete,确认结果一样。两种修法都亲手写一次。
  3. 写一个 debounce,连续调用五次,在真正的回调里累加一个计数,最后打印应该是 1;再调用一次 cancel(),确认回调不再执行。
  4. 打开内存面板拍一次快照,反复切换页面十次,再拍一次,对比 Detached DOM 数量。涨了就去查监听和解绑。
  5. 搜项目里的模块顶层 let,逐个问自己:这个状态该不该收进工厂函数的闭包,还是本来就该由调用方持有。

下一篇讲对象与原型链,它们是顺着这篇往下走的。闭包解决的是「变量放在哪个作用域、活多久」,对象解决的是「一堆数据和方法怎么组织」;而原型链决定了你调用一个方法时,它到底是从实例自己身上找到的,还是从某个共享的原型上找到的。这篇里 createCounter 每实例一份方法的问题,下一篇会给出另一种答案:让方法只存一份,所有实例共用。读完回头看你写的计数器,会有更清楚的选择。