闭包是 javascript 中一个核心概念，但它并非孤立存在，而是与作用域、模块化、回调函数等紧密相连。
javascript 采用词法作用域（静态作用域），即函数的作用域在定义时就已确定，而不是在执行时确定。这意味着，一个函数可以访问其外部函数中声明的变量，这种访问规则由作用域链（scope chain）实现。
当一个内部函数引用了外部函数的变量，并且这个内部函数在外部函数执行完毕后仍然可用（例如被返回或传递给其他函数），就形成了闭包。此时，即使外部函数已执行结束，其变量对象仍被内部函数引用，不会被垃圾回收。这正是闭包对作用域的“延长”效果。
1 2 3 4 5 6 7 8 9 function outer() { let x = 10; function inner() { console.log(x); // 内部函数引用外部变量 } return inner; } const closure = outer(); closure(); // 10 // 闭包保留了 outer 的作用域
闭包是作用域链的具体体现，它让函数能够“记住”并访问其词法作用域，即使函数在当前作用域之外执行。
模块化旨在将代码分割成独立、可复用的单元，同时隐藏内部实现细节，只暴露公共接口。在 ES6 模块出现之前，javascript 没有原生的模块系统，开发者利用闭包实现“模块模式”。
通过立即执行函数表达式（IIFE）创建私有作用域，返回一个包含公共方法的对象。这些公共方法通过闭包访问私有变量，从而实现信息隐藏。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 const counterModule = (function() { let count = 0; // 私有变量 function changeBy(val) { count += val; } return { increment() { changeBy(1); }, decrement() { changeBy(-1); }, getCount() { return count; } }; })(); counterModule.increment(); console.log(counterModule.getCount()); // 1 console.log(counterModule.count); // undefined，无法直接访问私有变量
在这个例子中，count 和 changeBy 被封装在闭包中，外部只能通过返回的对象操作它们。这正是闭包对模块化的支持。
ES6 模块（import/export）虽然语法不同，但底层仍然利用了闭包的特性。每个模块都有自己的作用域，导出内容相当于暴露了公共接口，而模块内部的变量对外部不可见，本质也是闭包的一种应用。
闭包是实现模块化的重要工具，它通过函数作用域和变量引用来创建私有空间，为模块化提供了语言层面的基础。
回调函数经常在异步操作（如事件监听、定时器、网络请求）中使用。当回调执行时，原始的执行上下文可能已经结束，但回调往往需要访问当时的数据。闭包正好解决了这个问题——回调函数定义时捕获的外部变量会被保留。
1 2 3 4 5 6 7 8 9 function fetchData(url) { const requestId = Math.random(); // 模拟请求ID setTimeout(function callback() { console.log(`请求 ${url} 完成，ID: ${requestId}`); }, 1000); } fetchData('/api/data'); // 一秒后输出：请求 /api/data 完成，ID: 0.123456...
这里的 callback 是一个闭包，它记住了 url 和 requestId，即使 fetchData 早已执行完毕。
许多高阶函数（如 map、filter、forEach）接受回调函数作为参数，这些回调同样可以形成闭包。
1 2 3 4 5 6 7 8 9 function createMultiplier(factor) { return function (number) { return number * factor; // factor 被闭包捕获 }; } const numbers = [1, 2, 3]; const doubled = numbers.map(createMultiplier(2)); console.log(doubled); // [2, 4, 6]
createMultiplier(2) 返回的函数作为回调传给 map，它捕获了 factor 变量。
在事件监听中，闭包常用于保存循环变量等状态。
1 2 3 4 5 6 7 const buttons = document.querySelectorAll('button'); for (var i = 0; i < buttons.length; i++) { buttons[i].addEventListener('click', function() { console.log(`按钮 ${i} 被点击`); // 闭包捕获 i }); } // 但输出总是 '按钮 3 被点击'（如果使用 var）
这就是著名的循环陷阱，因为 var 没有块级作用域，所有回调共享同一个 i。利用闭包可以修复：
1 2 3 4 5 6 7 for (var i = 0; i < buttons.length; i++) { (function(j) { buttons[j].addEventListener('click', function() { console.log(`按钮 ${j} 被点击`); // 闭包捕获 j }); })(i); }
回调函数常常以闭包的形式存在，因为它需要在未来某个时刻访问定义时的环境。闭包让回调变得“有记忆”，是异步编程的基础。
考虑一个简单的计数器模块，它支持异步增量操作：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 const counter = (function() { let count = 0; // 闭包私有变量（模块化） function asyncIncrement(delay) { setTimeout(function callback() { count++; // 回调闭包访问 count console.log(`当前计数: ${count}`); }, delay); } function getCount() { return count; } return { asyncIncrement, getCount }; })(); counter.asyncIncrement(1000); counter.asyncIncrement(1000); // 一秒后依次输出： // 当前计数: 1 // 当前计数: 2
作用域：count 存在于模块的闭包作用域中，callback 通过作用域链访问它。
五、总结
概念
与闭包的关系
作用域
闭包是基于词法作用域产生的，它让函数可以持续访问定义时的作用域。
模块化
闭包是实现模块模式的关键技术，通过私有变量和公共接口实现封装。
回调函数
回调函数常作为闭包出现，以便在异步执行时保留所需的环境变量。
闭包不仅是 javascript 的特性，更是连接这些编程范式的重要桥梁。