闭包的底层逻辑：词法作用域与变量引用的绑定机制

最新推荐文章于 2025-12-15 07:24:15 发布

原创最新推荐文章于 2025-12-15 07:24:15 发布 · 875 阅读

19 ·

CC 4.0 BY-SA版权

文章标签：

#前端 #javascript

前端同时被 2 个专栏收录

40 篇文章

订阅专栏

ES6

18 篇文章

订阅专栏

部署运行你感兴趣的模型镜像

闭包（Closure）是 函数编程中的核心概念，本质是：一个函数与其词法作用域（定义时所处的环境）的绑定关系—— 即使函数在其词法作用域之外执行，依然能访问、修改作用域内的变量。

简单说：闭包 = 函数 + 函数定义时的 “环境快照”（环境包含该作用域内的变量、参数等）。

一、先看一个直观例子（JavaScript）

// 外层函数：定义词法作用域
function outer() {
  let count = 0; // 外层作用域的变量（被闭包“捕获”）
  
  // 内层函数：闭包函数
  function inner() {
    count++; // 访问外层作用域的 count
    console.log(count);
  }
  
  return inner; // 外层函数返回内层函数（脱离原作用域）
}

// 执行外层函数，得到闭包函数（此时 outer 已执行完毕，其作用域本应销毁）
const closure = outer();

// 多次调用闭包函数（在 outer 作用域之外执行）
closure(); // 1（仍能访问 count）
closure(); // 2（count 被持续修改）
closure(); // 3

关键现象：

outer 执行后，其局部变量 count 没有被垃圾回收（正常函数执行完，局部变量会销毁）；
inner 函数即使脱离了 outer 的作用域，依然能 “记住” 并操作 count—— 这就是闭包的作用。

二、闭包的核心条件（3 个）

嵌套函数：存在内层函数和外层函数（或函数嵌套结构）；
作用域访问：内层函数引用了外层函数（词法作用域）的变量 / 参数；
脱离作用域执行：内层函数在其词法作用域（外层函数）之外被调用（如返回给外部、作为回调传递）。

三、闭包的本质：词法作用域的 “绑定”

编程语言的作用域规则分两种：

动态作用域：函数的作用域由 “执行时的环境” 决定（如 Bash）；
词法作用域：函数的作用域由 “定义时的环境” 决定（如 JavaScript、Python、Java 8+）。

闭包的实现依赖 词法作用域—— 内层函数定义时，会 “捕获” 外层作用域的变量引用，而非变量的副本。即使外层函数执行完毕，只要闭包还存在，被捕获的变量就不会被销毁。

四、闭包的典型用途

保存状态（变量私有化）：实现 “私有变量”，避免全局污染。例：计数器、缓存工具（如防抖节流中的定时器状态）。

// 防抖函数（闭包保存定时器状态）
function debounce(fn, delay) {
  let timer = null; // 闭包捕获 timer
  return function(...args) {
    clearTimeout(timer);
    timer = setTimeout(() => fn.apply(this, args), delay);
  };
}

延迟执行 / 回调复用：函数定义后，在其他地方（如异步回调、事件监听）执行时，仍能访问原作用域的变量。

// 异步回调中使用闭包
function fetchData(id) {
  fetch(`/api/data/${id}`)
    .then(res => res.json())
    .then(data => {
      console.log(`ID: ${id} 的数据：`, data); // id 被闭包捕获
    });
}
fetchData(1); // 异步执行时仍能访问 id=1

函数工厂（批量生成相似逻辑的函数）：根据外层参数，生成带有特定逻辑的内层函数。

# Python 示例：生成加法函数
def make_adder(x):
    def adder(y):
        return x + y  # 捕获 x
    return adder

add5 = make_adder(5)
print(add5(3))  # 8（x=5 被闭包保存）
add10 = make_adder(10)
print(add10(3)) # 13（不同闭包的 x 互不干扰）

五、闭包的注意事项

内存泄漏风险：如果闭包长期存在（如全局变量引用），被捕获的变量会一直占用内存，无法被垃圾回收。解决：不需要时手动解除引用（如 closure = null）。

循环中的闭包陷阱（早期 JavaScript 常见）：

// 错误示例：循环中生成的闭包共享同一个 i
for (var i = 0; i < 3; i++) {
  setTimeout(() => console.log(i), 1000); // 输出 3、3、3（i 最终为 3）
}

// 解决：用 let 块级作用域（每个循环生成独立闭包环境）
for (let i = 0; i < 3; i++) {
  setTimeout(() => console.log(i), 1000); // 输出 0、1、2
}

变量引用而非副本：闭包捕获的是变量的 “引用”，而非定义时的值。如果外层变量被修改，闭包访问到的是修改后的值：

let x = 1;
function outer() {
  function inner() {
    console.log(x);
  }
  x = 2; // 修改 x
  return inner;
}
const closure = outer();
closure(); // 输出 2（而非 1）