概念

简单理解：函数中的函数，就是闭包。也可以说是：有权访问另一个函数作用域中的变量的函数。

1. 闭包也是函数，只不过比较特殊。

2. 闭包的优点，也是它的缺点：可以把局部变量驻留在内存中，因此可以避免使用全局变量。当代码量足够大时，使用全局变量会发生命名的冲突、各个地方的对全局变量的修改而导致的一系列问题。

3. 由于闭包会导致局部变量不被回收，可能会消耗内存。因此，在闭包使用结束后，应将闭包设置为 null 。

function f(){
    var age = 100;
    return function(){
        age++;
        return age;
    }
}
var fi = f();
for(var x = 0;x<10;x++){
    console.log(fi())
}
fi = null;//回收闭包

4. 使用闭包时，闭包的外部函数应该只调用一次。因为每调用一次外部函数，函数中的局部变量就会被重新初始化。上例中，只调用了一次 f()，保证 age 只被寝化一次。

5. 各个闭包函数共享外部函数的所有变量，一个函数对变量进行修改，所有的闭包函数都会随之变化。

   function Outer(value){
       var a = value; 
       m1 = function(){
           console.log('m1.a = '+a)
           a = 'm1'
       }
       m2 = function(){
           console.log('m2.a = '+a)
           a = 'm2'
       }
   }
   Outer('init')
   
   m1() // m1.a = init
   m2() // m2.a = m1
   m1() // m1.a = m2
   

   m1，m2 各输出当前 a 的值，并进行修改。可以发现，m2 输出的就是 m1 修改后的值。而 m1 输出的也是 m2 修改后的值。

取值问题

在下面代码中，输出的结果是 5。

function Fun () {
    var r = [];
    for(var x = 0;x<5;x++){
        r[x] = function(){
            return x;
        }
    }
    return r;
}
console.log(Fun()[0]()) // 输出的是 5

这是因为在执行完 Fun() 时，函数内部的循环已经执行完毕，x 值也变成了 5。所以在执行 r 的第一个函数时，取到 x 值就是 5。
可以改成如下形式：

function Fun () {
    var r = [];
    for(var x = 0;x<5;x++){
        r[x] = (function(num){
            return function inner(){
                return num
            }
        })(x) // 自动执行匿名函数
    }
    return r;
}
var r = Fun()
for(var x = 0;x<5;x++){
    console.log(r[x]()) // 依次输出0到4
}

匿名函数执行时，会将 x 值传递到匿名函数中，而匿名函数内部有一个闭包，会将传入的 x 值驻留在内存中。这导致每一个匿名函数内部的闭包对应不同的 num 值。因此，在输出是输出的是 0 到 4。

闭包中的 this

由于闭包也是一个函数，所以它中的 this 指向了运行该函数的对象。

如:

var age = "window.age"
var o = {
    age:'o.age',
    getThis:function(){
        return this.age;
    }
}
console.log(o.getThis()) // a.age

var o2 = {
    age:'o2.age',
    getThis:function(){
        return function(){
            return this.age;
        }
    }
}
console.log(o2.getThis()()) // window.age

var o3 = {
    age:'o3.age'
}
console.log(o2.getThis().call(o3)) //o3.age

第二次输出时，相当于在 window 下直接运行了闭包，所以闭包中的 this 指向了 window 中的 age 属性。

第三次输出时，通过对象冒充的方式，使得闭包在 o3 对象中运行，所以闭包中的 this 指向了 o3 中的 age 属性。

指向外部函数

由于闭包执行时，this 指向的是调用闭包的对象。如果想让 this 指向闭包的外部函数，可以如下修改：

var o2 = {
    age:'o2.age',
    getThis:function(){
        var that = this; // 用 that 变量记录执行外部函数时 this 的指向
        return function(){
            return that.age; // 闭包，保证 that 变量的全局性
        }
    }
}
console.log(o2.getThis()()) // o2.age

在外部函数中使用一个变量记录外部函数的 this，并在闭包中使用该变量代替
this，由于闭包的特性，可以保证该变量能常驻内存，所以在执行闭包时该变量就表示了外部函数的 this 。

模仿块级作用域

js 中没有块级作用域。if for ,while 等语句执行完毕后，{} 内的变量外界依旧可以访问。但，函数内部的变量却是局部变量。所以， 可以使用匿名函数模仿块级作用域——使用一个自执行的匿名函数将要分块代码包裹起来即可

for(var i = 0;i<10;i++){}
console.log(i); // 10

(function(){
    for(var x = 0;x<10;x++){}
})() 
console.log(x) // 此处访问 x 出错