javascript闭包

　在学习javascript闭包之前，需要先了解一下"作用域链"。

每一段javascript代码都有一个与之关联的作用域链(scope chain)，这个作用域链是一个对象列表或者链表，这组对象定义了这段代码"作用域中"的变量。当javascript需要查找变量x的值的时候，它会从链中的第一个对象开始查找，如果这个对象有一个名为x的属性，则会直接使用这个属性的值，如果第一个对象不存在名为x的属性，javascript会继续查找链上的下一个对象。如果第二个对象依然没有名为x的属性，则会继续查找下一个对象，以此类推。如果作用域链上没有任何一个对象含有属性x，那么就认为这段代码的作用域链上不存在x，并最终抛出一个引用错误异常。

　　当定义一个函数的时候，它实际上保存了一个作用域链，当调用这个函数的时候，它创建一个新的对象来存储它的局部变量，并将这个对象添加至保存的那个作用域链上，同时创建一个新的更长的表示函数调用作用域的"链"。

　　函数对象可以通过作用域链关联起来，函数体内部的变量都可以保存在函数作用域内，这种特性就称为"闭包"。也可以这样理解闭包，函数变量可以被隐藏于作用域链之内，看起来是函数将变量"包裹"了起来。

　　概念说了一堆，来个示例可能会比较清晰。

　　var a = 1;

　　function testFun(){

　　　　var a = 10;

　　　　function tempFun(){return a;}

　　　　return tempFun();　　　　

　　}

　　testFun();

　　上述例子执行的结果是返回10。

　　对于上述例子，我们来做一下改动。

　　var a = 1;

　　function testFun(){

　　　　var a = 10;

　　　　function tempFun(){return a;}

　　　　return tempFun;

　　}

　　testFun()();

　　对于这个例子，很多人会下意识的认为返回结果为1，理由就是函数tempFun是在全局环境下执行的，因此会返回1。然而结果是返回10。

　　由于javascript函数的执行用到了作用域链，这个作用域链是函数定义的时候创建的。

　　嵌套的函数tempFun定义在这个作用域链里，其中的变量a是局部变量，不管在什么时候执行函数tempFun，这种绑定在执行tempFun依然有效，因此结果返回10而不是1。

　　这里我们可以看到闭包的强大之处：它们可以捕捉到局部变量（参数），并一直保存下来，看起来像这些变量绑定到了在其中定义它们的外部函数。

众所周知，javascript没有块级作用域，只有函数作用域。那就意味着定义在函数中的参数和变量在函数外部是不可见的，而在一个函数内部任何位置定义的变量，在该函数内部任何地方都可见。这带来的好处是内部函数可以访问定义它们的外部函数的参数和变量。

首先，我们来构造一个简单的对象

 1 var testObj = {
 2     value: 10,
 3     add: function(inc){
 4         this.value += (typeof inc === "number") ? inc : 1;
 5     }
 6 };
 7 
 8 testObj.add();
 9 testObj.value;    // 11
10 
11 testObj.add(2);    
12 testObj.value;    // 13

这样写就有一个问题，value值不能保证不会被非法修改，可以按如下的方法进行修改。

 1 var testObj = (function(){
 2     var value = 10;
 3     return {
 4         add: function(inc){
 5             value += (typeof inc === "number") ? inc : 1;
 6         },
 7         getValue: function(){
 8             return value;
 9         }
10     };
11 })();
12 
13 testObj.add();
14 testObj.getValue();    // 11
15 
16 testObj.add(2);
17 testObj.getValue(); // 13

我们可以通用调用一个函数的形式去初始化testObj，该函数会返回一个对象字面量，函数里定义了一个value变量，该变量对add和getValue方法总是可用的，但函数的作用域使得它对其他的程序来说是不可见的。同时，我们还可以得出一个结论，内部函数拥有比它的外部函数更长的生命周期。

我们再继续看一个构造函数调用的例子。

var MyObj = function(str){
    this.status = str;
};

MyObj.prototype.getStatus = function(){
    return this.status;
};

var obj = new MyObj("javascript");
obj.getStatus(); // "javascript"

这样写并没有错，但是会有一点“多此一举”，为什么要用一个getStatus方法去访问一个本可以直接访问到的属性呢？如果status是私有属性，那当然才有意义。

var obj = function(status){
    return {
        getStatus: function(){
            return status;
        }
    };
};

var myObj = obj("javascript");
myObj.getStatus(); // "javascript"

这里当我们调用obj的时候，它返回包含getStatus方法的一个新对象，该对象的一个引用保存在myObj中，即使obj已经返回了，但getStatus方法仍然享有访问obj对象的status属性的特权。getStatus方法并不是访问该参数的一个副本，它访问的就是该参数本身。这是可能的，因为该函数可以访问它被创建时所处的上下文环境，这被称为闭包。