发布时间：2023-05-06 09:30
通俗来讲，闭包就是使内层函数可以访问到其外层函数的作用域，即使该内层函数被调用过，该外层函数中变量仍会保存在内存中，不会被销毁。在JavaScript中，每当创建一个函数，闭包就会在函数创建的同时被创建出来。
官方说法，闭包指的是一个函数和对其周围状态（词法环境）的引用捆绑在一起形成的组合。
词法一词指的是，词法作用域根据源代码中声明变量的位置来确定该变量在何处可用。
嵌套函数（闭包）可访问声明与它们外部作用域的变量。
个人认为，在JS中，当前作用域内的变量，在该变量所处的作用域内(包含当前作用域的所有子作用域内），都可以进行调用。这也是为什么闭包形成的环境可以调用外部作用域变量的原因。
例如在下列代码中：
function main(){
let a = 'hello';
for ( let i = 0; i < 5; i++){
let b = a + 'world';
console.log(b);
}
}变量a在for循环中仍然可以使用，但变量b却只能在for循环内进行使用。
因为变量b的作用域（词法环境）为for循环，而变量a的作用域（词法环境）是当前main函数内。
但闭包相比于上述解释之外，更重要的地方在于，当闭包所处的外部函数被调用后，该闭包所调用的外部变量仍然可用，并没有被销毁。因为闭包是由函数以及声明该函数的词法环境组合而成的。该环境包含了这个闭包创建时作用域内的任何局部变量。
我们通过一个简单的加法函数来解释一下闭包：
function makeAdder(x) {
return function(y) {
return x + y;
};
}
var add5 = makeAdder(5);
var add10 = makeAdder(10);
console.log(add5(2)); // 7
console.log(add10(2)); // 12
在上述代码中，定义了 makeAdder(x) 函数，它接受一个参数 x ，并返回一个新的函数（这个新的函数就是闭包）。返回的函数接受一个参数 y，并返回x+y的值。
从本质上讲，makeAdder 是一个函数工厂 — 他创建了将指定的值和它的参数相加求和的函数。在上面的示例中，使用函数工厂创建了两个新函数 — 一个将其参数和 5 求和，另一个和 10 求和。
add5 和 add10 都是闭包（即makeAdder(x）函数返回的那个函数）。它们共享相同的函数定义，但是保存了不同的词法环境。在 add5 的环境中，x 为 5。而在 add10 中，x 则为 10。
var makeCounter = function() {
var privateCounter = 0;
function changeBy(val) {
privateCounter += val;
}
return { // return的是一个对象，对象里每个键对应的值是一个函数，因此调用时要加()
increment: function() {
changeBy(1);
},
decrement: function() {
changeBy(-1);
},
value: function() {
return privateCounter;
}
}
};
var Counter1 = makeCounter();
var Counter2 = makeCounter();
console.log(Counter1.value()); /* 输出 0 */
Counter1.increment();
Counter1.increment();
console.log(Counter1.value()); /* 输出 2 */
Counter1.decrement();
console.log(Counter1.value()); /* 输出 1 */
console.log(Counter2.value()); /* 输出 0 */
上述代码实现了两个相互独立的计数器。
makeCounter是计时器工厂，return的闭包是一个对象，该对象里每个键对应的值都是一个函数。
该对象里的每一个函数都可以调用makeCounter工厂提供的privateCounter变量和changeBy()方法。同时private变量和changeBy()方法不会在调用结束后失效。
Counter1和Counter2都是由makeCounter生成的闭包。
因为该闭包是一个对象（前一个例子里闭包是一个函数），因此在调用闭包内的方法时，正确写法是Counter1.value()，而不是Counter.value,这是我自己实践时踩坑的一个点。
在 ECMAScript 2015 引入let关键字之前，在循环中有一个常见的闭包创建问题（推荐大家在平常写代码时使用let和const，var变量容易有变量提升等问题，不推荐使用）。参考下面的示例：
Helpful notes will appear here
E-mail:
Name:
Age:
function showHelp(help) {
document.getElementById('help').innerHTML = help;
}
function setupHelp() {
var helpText = [
{'id': 'email', 'help': 'Your e-mail address'},
{'id': 'name', 'help': 'Your full name'},
{'id': 'age', 'help': 'Your age (you must be over 16)'}
];
for (var i = 0; i < helpText.length; i++) {
var item = helpText[i];
document.getElementById(item.id).onfocus = function() {
showHelp(item.help);
}
}
}
setupHelp();
在上述代码中，执行setupHelp()方法后，并不会按照预期使得焦点落到三个input时，id为help的p标签显示该input对应的help语句。而是统一显示helpText最后一个数组元素的help。
这是因为变量item使用var进行声明，由于变量提升，所以具有函数作用域（详见我下一篇博客讲解什么是函数作用域）。
而赋值给 onfocus 的是闭包，这些闭包是由他们的函数定义和在 setupHelp 作用域中捕获的环境所组成的。这三个闭包在循环中被创建，但他们共享了同一个词法作用域，在这个作用域中存在一个变量item。
当onfocus的回调执行时，item.help的值被决定。由于循环在事件触发之前早已执行完毕，变量对象item（被三个闭包所共享）已经指向了helpText的最后一项。
因此导致最终被赋予同样的值。
针对该问题，有四种解决方法。最优的方式就是下列讲述的第一种，后面两种大家可以仅做了解
1. 用let来替换var
function showHelp(help) {
document.getElementById('help').innerHTML = help;
}
function setupHelp() {
var helpText = [
{'id': 'email', 'help': 'Your e-mail address'},
{'id': 'name', 'help': 'Your full name'},
{'id': 'age', 'help': 'Your age (you must be over 16)'}
];
for (var i = 0; i < helpText.length; i++) {
let item = helpText[i];
document.getElementById(item.id).onfocus = function() {
showHelp(item.help);
}
}
}
setupHelp();let的声明方式使得每个闭包都绑定了块作用域的变量，有效解决由于var变量提升带来的问题。
2. 使用匿名闭包
function showHelp(help) {
document.getElementById('help').innerHTML = help;
}
function setupHelp() {
var helpText = [
{'id': 'email', 'help': 'Your e-mail address'},
{'id': 'name', 'help': 'Your full name'},
{'id': 'age', 'help': 'Your age (you must be over 16)'}
];
for (var i = 0; i < helpText.length; i++) {
(function() {
var item = helpText[i];
document.getElementById(item.id).onfocus = function() {
showHelp(item.help);
}
})(); // 马上把当前循环项的item与事件回调相关联起来
}
}
setupHelp();匿名闭包使得每一个闭包和它所在的词法环境与其他闭包相互独立，从而解决变量提升导致的问题。
3. 使用 forEach()来遍历helpText数组并给每一个
添加一个监听器。
function showHelp(help) {
document.getElementById('help').innerHTML = help;
}
function setupHelp() {
var helpText = [
{'id': 'email', 'help': 'Your e-mail address'},
{'id': 'name', 'help': 'Your full name'},
{'id': 'age', 'help': 'Your age (you must be over 16)'}
];
helpText.forEach(function(text) {
document.getElementById(text.id).onfocus = function() {
showHelp(text.help);
}
});
}
setupHelp();4. 使用更多的闭包来约束词法环境
function showHelp(help) {
document.getElementById('help').innerHTML = help;
}
function makeHelpCallback(help) {
return function() {
showHelp(help);
};
}
function setupHelp() {
var helpText = [
{'id': 'email', 'help': 'Your e-mail address'},
{'id': 'name', 'help': 'Your full name'},
{'id': 'age', 'help': 'Your age (you must be over 16)'}
];
for (var i = 0; i < helpText.length; i++) {
var item = helpText[i];
document.getElementById(item.id).onfocus = makeHelpCallback(item.help);
}
}
setupHelp();
这段代码可以所期望的那样工作。所有的回调不再共享同一个环境， makeHelpCallback 函数为每一个回调创建一个新的词法环境。在这些环境中，help 指向 helpText 数组中对应的字符串。
1. 好处
（1）闭包使得外部可以读取函数内的局部变量。
javascript语言的特别之处就在于：函数内部可以直接读取全局变量，但是在函数外部无法读取函数内部的局部变量。
为了使外部可以读取函数内变量，我们可以通过闭包，即在函数A内再返回一个函数B,从而使得外界可以读取函数A内的变量。
（2）闭包使得变量的安全性更高。
编程语言中，比如 Java，是支持将方法声明为私有的，即它们只能被同一个类中的其它方法所调用。
而 JavaScript 没有这种原生支持，但我们可以使用闭包来模拟私有方法。私有方法不仅仅有利于限制对代码的访问：还提供了管理全局命名空间的强大能力，避免非核心的方法弄乱了代码的公共接口部分。
例如我们前面4提出的实现一个闭包环境的计数器。
外界不需要关心这个makeCounter工厂是怎么工作的，只需要按要求调用响应的方法，即可实现相应的效果。感觉这又衍生出了工厂模式的知识点呢哈哈。
2. 坏处：
闭包在很多情况下确实很好用，但是因为闭包的调用最终是赋给了一个全局变量，所以导致它会一直存在于内存中，不会被js的垃圾回收机制回收，从而会影响计算机的性能，更严重点可能会导致内存泄露。因此在日常开发中，如果能不使用，还是减少使用吧~
刚在网上翻资料，又看到闭包相关的this指向问题。感兴趣的小伙伴可以运行看看效果：
var name = "The Window";
var object = {
name : "My Object",
getNameFunc : function(){
return function(){
return this.name;
};
}
};
alert(object.getNameFunc()());
var name = "The Window";
var object = {
name : "My Object",
getNameFunc : function(){
var that = this;
return function(){
return that.name;
};
}
};
alert(object.getNameFunc()());