闭包、作用域和模仿块级作用域

闭包：

有权访问另一个函数作用域中的变量的函数。我的理解是：能够读取其他函数内部变量的函数。由于在 Javascript 中，只有函数 a 内部的子函数b才可以读取函数 a 的局部变量，所以把闭包简单理解成：定义在一个函数内部的函数。创建闭包的常见的方式就是，在一个函数内部创建另一个函数。

例一、

function a(){
    var i = 0;
    function b(){
        i++;
        alert(i);
    }   
    return b;   
}
var c = a();
c();        //1

如上面函数 b 就是闭包，但前提是：当函数 a 的内部函数 b 被 a 外的一个变量 c 引用的时候，就创建了一个所谓的“闭包”。意思是，b要变成闭包的话，就必须被外包 c 所引用。

---

变量的作用域：

要理解闭包，首先要理解 Javascript 的变量作用域。

当某个函数被调用时，会创建一个执行环境及相应的作用域链。然后使用 arguments 和其他变量参数的值来初始化函数的活动对象。但在作用域中，外部函数的活动对象始终处于第二位……直到作为作用域终点的全局执行环境。

变量的作用域有两种：全局变量和局部变量

---

全局变量：

函数内部可以直接读取全局变量

var n = 1;
function func(){
    alert(n);
}
func();     //1

局部变量：

函数外部无法读取函数内的局部变量

function func(){
    var n = 1;
}
alert(n);       //error

一般来说，函数执行完毕后，局部活动对象就会被销毁，内存中仅保存全局作用域（全局执行环境的变量对象），但闭包的环境又有所不同。
如例一所示，当函数 a 执行完毕后，其活动对象也不会被销毁，因为函数 b 的作用域链仍然在引用这个活动对象，换句话说，当函数 a 返回后，其执行环境的作用域链会被销毁，但它的活动对象仍然保存在内存中，直到函数 b 被销毁，a 的活动对象才会被销毁。

有时候，我们需要得到函数内的局部变量。但一般情况下是没办法访问到的。但是，在函数内部，再定义一个函数，那么，内部定义的函数能够访问到它的外包函数。例如：

function outer（）{
    var n = 1;
    function inner(){
        alert(n);      //1
    }
}

在上述代码中，函数 inner 被包含在函数 outer 内部，此时 outer 内部的所有局部变量，都可以被 inner 访问，但反过来不行，inner 内部的局部变量，不能被 outer 访问，这就是 Javascript 语言特有的”链式作用域“结构，子对象会一级一级地向上寻找所有父对象的变量，所以父对象的所有变量，对子对象都是可见的，反之则不成立。

既然 inner 可以访问到 outer 的局部变量，那么只要把 inner 作为返回值，我们就可以在 outer 外部读取 outer 的局部变量了。例如：

function outer（）{
    var n = 1;
    function inner(){
        alert(n);
    }
    return inner;
}

var result = outer();
result();       //1

此处：inner 函数就是闭包。

闭包的最大的两个用处：

1. 读取函数内部的变量
2. 让这些变量的值始终保持在内存中。

例如：

function outer(){
    var n = 1;
    nAdd = function(){  //没有使用var 则nAdd为全局函数
        n++;
   };
　　function inner(){
        console.log(n);
　　}
　　return inner;
}
var result = outer();
result(); // 1

nAdd();
result(); // 2

在这段代码中，result 实际上就是闭包 inner 函数，它一共运行 2 次，第一次的值为 1，第二次的值为 2，由此证明，函数 outer 中的局部变量 n 一直保存在内存中，并没有在内存中，并没有因为 outer 调用后被自动清除。

因为 outer 是 inner 的父级函数，而 inner 被赋值给一个全局变量 result，这导致 inner 始终在内存中，而 inner 的存在依赖于 outer，因此 outer 也始终在内存中，不会在调用结束后，被垃圾回收机制（garbage collection） 回收。

注意：代码中，nAdd = function(){n++}，首先在 nAdd 前面没有使用 var 关键字，因此 nAdd 是一个全局变量，而不是 outer 的局部变量。其次，nAdd 的值是一个匿名函数，而这个匿名函数本身也是一个闭包，所以 nAdd 相当于一个 setter，可以在函数外部对函数内部的局部变量进行操作。

使用闭包的注意点：

1. 由于闭包会使得函数中得变量都被保存在内存中。内存消耗很大，所以不能滥用闭包，否则会造成网页的性能问题，在IE中可能导致内存泄露。解决方法是，在退出函数之前，将不使用的局部变量全部删除。
2. 闭包会在父函数外部，改变父函数的内部变量的值，所以，如果把父元素当作对象使用，把闭包当作它的共有方法，把内部变量当作它的私有属性，这时要小心，不要随便改变父函数内部变量的值。

---

关于闭包的this对象

var name = "The Window";
var object = {
    name : "My Object",
    getNameFunc : function(){
        return function(){
　　　　　　　　return this.name;
　　　　　};
　　　}
};
alert(object.getNameFunc()());      //"The Window";(在非严格模式下)

我们知道，this 对象是在运行时基于函数的执行环境绑定的：在全局函数中，this 等于window，而当函数被作为某个对象的方法调用时，this 等于那个对象。不过匿名函数的执行环境具有全局性，因此，其 this 对象通常指向 window。

不过，把外部作用于中的 this 对象保存在一个闭包能够访问到的变量里，就可以让闭包访问该对象了。

var name = "The Window";
var object = {
    name : "My Object",
    getNameFunc : function(){
        var that = this;
        return function(){
            return that.name;
　　　　　};
　　　}
};
alert(object.getNameFunc()());      // "My Object"

在定义匿名函数之前，我们把 this 对象复制给了一个名叫 that 的变量。而在定义了闭包之后，闭包也可以访问这个变量，因为它是在包含函数中特意声明的一个变量。几时在函数返回之后，that 也任然引用着 object，所以调用 object.getNameFunc()() 就返回了 “My Object”。

在特殊的情况下，this 的值可能会意外地改变，如：

var name = "The Window";
var object = {
    name : "My Object",
    getName : function(){
        return this.name;
    }
}

object.getName();       //"My Object"
(object.getName)();     //"My Object"
(object.getName = object.getName)();    //"The Window"

---

模仿块级作用域

Javascript 没有块级作用域的概念，而且，它不会告诉你是否多次生命了同一个变量，如果，后面对一个变量声明，则，会对后面的声明视而不见（但会执行后续声明中的变量初始化）。如：

function outputNumbers(count){
    for(var i = 0;i<count;i++){
        alert(i);
    }
    var i;     //重新声明变量
    alert(i);   //计数
}

匿名函数可以用左模仿块级作用域（私有作用域）并避免上述问题

(function(){
    //这里是块级作用域
})();

以上代码定义并立即执行一个匿名函数，将函数声明包含在第一对括号中，表示它实际上是一个函数表达式，而紧随其后的另一对圆括号会立即调用这个函数。

function outputNumbers(count){
    (function (){
        for(var i = 0;i<count;i++){
            alert(i);
        }
    })();
    alert(i);   //error
}

---

私有静态变量：

(function(){
    var privateStatic = "privatestatic";
    Func = function(){
        this.setPrivateStatic = function(value){
            privateStatic = value;
        }
        this.getPrivateStatic = function(){
            return privateStatic;
        }
    }
})();

var func1 = new Func();
var func2 = new Func();
console.log(func1.getPrivateStatic());// privatestatic
console.log(func2.getPrivateStatic());// privatestatic

console.log(func1.setPrivateStatic('changed')); 
console.log(func2.getPrivateStatic()); //changed

注意：privateStatic 并非对象 Func 里的成员变量，所以，创建的 Func 实例对象，不会创建 privateStatic。而且 Func 没有使用 var 声明，因此，Func 是全局变量。例子中，Func 的构造函数与 setPrivateStatic（）和 getPrivateStatic（）都有权访问私有变量 privateStatic 。在这种模式下，privateStatic 变量就变成了一个静态的，由所有实例共享的属性，也就是说，在一个实例上调用 setPrivateStatic（）会影响所有实例。

参考内容