其实要理解 JavaScript 中的闭包，非常容易，但是在此之前你需要先知道以下两个知识点：
- JavaScript 中的作用域和作用域链
- JavaScript 中的垃圾回收
1. JavaScript 中的作用域和作用域链
- 作用域就是一个独立的地盘，让变量不会外泄、暴露出去，不同作用域下同名变量不会有冲突。
- 作用域在定义时就确定，并且不会改变。
- 如果在当前作用域中没有查到值，就会向上级作用域去查，直到查到全局作用域，这么一个查找过程形成的链条就叫做作用域链。
2. JavaScript 中的垃圾回收
- Javascript 执行环境会负责管理代码执行过程中使用的内存，其中就涉及到一个垃圾回收机制。
- 垃圾收集器会定期（周期性）找出那些不再继续使用的变量，只要该变量不再使用了，就会被垃圾收集器回收，然后释放其内存。如果该变量还在使用，那么就不会被回收。
闭包不是一个具体的技术，而是一种现象，是指在定义函数时，周围环境中的信息可以在函数中使用。换句话说，执行函数时，只要在函数中使用了外部的数据，就创建了闭包。
而作用域链，正是实现闭包的手段。
只要在函数中使用了外部的数据，就创建了闭包？真的是这样么？我们可以证明一下：
function outer() {
function inner() {
var i = 1;
console.log(i);
}
inner();
}
outer();
在上面的代码中，我们在函数 inner 中定义了一个变量 i，然后打印这个 i 变量。对于 inner 这个函数来讲，自己的函数作用域中存在 i 这个变量，所以我们在调试时可以看到 Local 中存在变量 i。
下面我们将上面的代码稍作修改
function outer() {
var i = 1;
function inner() {
console.log(i);
}
inner();
}
outer();
在上面的代码中，我们将声明 i 这个变量的动作放到了 inner 函数外面，也就是说 inner 函数在自己的作用域已经找不到这个 i 变量了，它会怎么办？
学习了作用域链的你肯定知道，它会顺着作用域链一层一层往外找。然而上面在介绍闭包时说过，如果出现了这种情况，也就是函数使用了外部的数据的情况，就会创建闭包。
仔细观察调试区域，我们会发现此时的 i 就放在 Closure 里面的，从而证实了我们前面的说法。
所以你看，闭包其实也没有那么难理解，当你觉得一个词对你来说特别难的时候，你还可以使用拆词法，这也是我比较推荐的屡试不爽的一种方法。
“闭”可以理解为“封闭，闭环”，“包”可以理解为“一个类似于包裹的空间”，因此闭包实际上可以看作是一个封闭的空间，那么这个空间用来干啥呢？实际上就是用来存储变量的。
那么是一个函数下所有的变量声明都会被放入到闭包这个封闭的空间里面么？
倒也不是，放不放入到闭包中，要看其他地方有没有对这个变量进行引用，例如：
function outer() {
var i = 10;
function inner() {
var j = 20;
var k = 30;
function inner2() {
var l = 40;
var m = 50;
var n = 60;
function inner3() {
console.log(i, j, k, l, m);
}
inner3();
}
inner2();
}
inner();
}
outer();
在上面的代码中，函数 inner3 中一个变量都没有创建，却要打印 i、j、k、l和m，这些变量分别存在于 outer、inner和inner2 函数中，因此创建了 3 个闭包，闭包 outer 中存储了变量 i 的值，闭包 inner 中存储了变量 j 和 k 的值，闭包 inner2 中存储了变量 l 和 m 的值。
但是你仔细观察，你就会发现函数 inner2 中的 n 变量并没有被放在闭包中，所以要不要放入闭包取决于该变量有没有被引用。
当然，此时的你可能会有这样的一个新问题，那么多闭包，那岂不是占用内存空间么？
实际上，如果是自动形成的闭包，是会被销毁掉的。例如：
function outer() {
var i = 10;
function inner() {
var j = 20;
var k = 30;
function inner2() {
var l = 40;
var m = 50;
var n = 60;
function inner3() {
console.log(i, j, k, l, m);
}
inner3();
}
inner2();
}
inner();
}
outer();
console.log(k) // Uncaught ReferenceError: k is not defined
在上面的代码中，我们尝试打印输出变量 k，显然这个时候是会报错的，打一个断点调试就可以清楚的看到，此时已经没有任何闭包存在，垃圾回收器会自动回收没有引用的变量，不会有任何内存占用的情况。
当然，这里我指的是自动产生闭包的情况，关于闭包，有时我们需要根据需求手动的来制造一个闭包。
来看下面的例子：
function drink(){
var beverage = 'Cola';
console.log(beverage);
}
drink(); // Cola
console.log(beverage); // Uncaught ReferenceError: beverage is not defined在上面的例子中，我们声明了一个名为 drink 的函数，并对它进行调用。
JavaScript 引擎会创建一个 drink 函数的执行上下文，其中声明 beverage 变量并赋值。
当该方法执行完后，上下文被销毁，beverage 变量也会跟着消失。这是因为 beverage 变量属于 drink 函数的局部变量，它作用于 drink 函数中，会随着 drink 的执行上下文创建而创建，销毁而销毁。所以当我们再次打印 beverage 变量时，就会报错，告诉我们该变量不存在。
但是我们将此代码稍作修改：
function drink(){
var beverage = 'Cola';
return function(){
console.log(beverage);
}
}
var fn = drink();
fn(); // Cola
fn(); // Cola在这个例子中，drink 函数返回一个函数，并在这个内部函数中访问 beverage 这个局部变量。调用 drink 函数并将结果赋给 fn 变量，这个 fn 指向了 drink 函数中的内部函数，然后调用它，最终输出 beverage 的值。
为什么能访问到 beverage，原因很简单，上面我们说过，垃圾回收器只会回收没有被引用到的变量，但是一旦一个变量还被引用着的，垃圾回收器就不会回收此变量。在上面的示例中，照理说 drink 调用完毕 beverage 就应该被销毁掉，但是我们向外部返回了 drink 内部的匿名函数，而这个匿名函数又引用了 beverage，所以垃圾回收器是不会对其进行回收的，这也是为什么在外面调用这个匿名函数时，仍然能够打印出 beverage 变量的值。
至此，闭包的一个优点或者特点也就体现出来了，那就是：
- 通过闭包可以让外部环境访问到函数内部的局部变量。
- 通过闭包可以让局部变量持续保存下来，不随着它的上下文环境一起销毁。
通过此特性，我们可以解决一个全局变量污染的问题。早期在 JavaScript 还无法进行模块化的时候，在多人协作时，如果定义过多的全局变量 有可能造成全局变量命名冲突，使用闭包来解决功能对变量的调用将变量写到一个独立的空间里面，从而能够一定程度上解决全局变量污染的问题。
例如：
// 全局变量
var name = 'GlobalName';
var init = (function () {
var name = 'initName';
function callName() {
console.log(name);
}
return callName;
})()
init(); // initName现在我们来对闭包做一个小小的总结：
- 闭包是一个封闭的空间，里面存储了在其他地方会引用到的该作用域的值，在 JavaScript 中是通过作用域链来实现的闭包。
- 只要在函数中使用了外部的数据，就创建了闭包，这种情况下所创建的闭包，我们在编码时是不需要去关心的。
- 我们还可以通过一些手段手动创建闭包，从而让外部环境访问到函数内部的局部变量，让局部变量持续保存下来，不随着它的上下文环境一起销毁。
闭包经典面试题
for (var i = 1; i <= 3; i++) {
setTimeout(function () {
console.log(i);
}, 1000);
}在上面的代码中，我们预期的结果是过 1 秒后分别输出 i 变量的值为 1，2，3。但是，执行的结果是：4，4，4。
实际上，问题就出在闭包身上。你看，循环中的 setTimeout 访问了它的外部变量 i，形成闭包。
而 i 变量只有 1 个，所以循环 3 次的 setTimeout 中都访问的是同一个变量。循环到第 4 次，i 变量增加到 4，不满足循环条件，循环结束，代码执行完后上下文结束。但是，那 3 个 setTimeout 等 1 秒钟后才执行，由于闭包的原因，所以它们仍然能访问到变量 i，不过此时 i 变量值已经是 4 了。
要解决这个问题，我们可以让 setTimeout 中的匿名函数不再访问外部变量，而是访问自己内部的变量，如下：
for (var i = 1; i <= 3; i++) {
(function (index) {
setTimeout(function () {
console.log(index);
}, 1000);
})(i)
}这样 setTimeout 中就可以不用访问 for 循环声明的变量 i 了。而是采用调用函数传参的方式把变量 i 的值传给了 setTimeout，这样它们就不再创建闭包，因为在我自己的作用域里面能够找到 i 这个变量。
当然，解决这个问题还有个更简单的方法，就是使用 ES6 中的 let 关键字。
它声明的变量有块作用域，如果将它放在循环中，那么每次循环都会有一个新的变量 i，这样即使有闭包也没问题，因为每个闭包保存的都是不同的 i 变量，那么刚才的问题也就迎刃而解。
for (let i = 1; i <= 3; i++) {
setTimeout(function () {
console.log(i);
}, 1000);
}