JS闭包

一、闭包的概念：

闭包是一个拥有许多变量和绑定了这些变量的环境的表达式（通常是一个函数），因此这些变量也是该表达式的一部分。用通俗的话来说，JS中的所有function都是一个闭包，但嵌套的function产生的闭包更为强大，这也是大部分时候我们所谓的闭包。

二、闭包的微观世界：

要深入理解闭包以及函数a和嵌套函数b的关系，我们需要了解函数执行环境（excution content）、活动对象（call object）、作用域（scope）和作用域链（scope chain）的概念。以函数a从定义到执行的过程为例来阐述这几个概念：

当定义函数a的时候，JS解释器会将函数a的作用域链设置为“定义a时a所在的环境”，如果a是一个全局函数，则作用域链中只有window对象；

当执行函数a时，a会进入相应的执行环境；

在创建执行环境的过程中，首先会为函数啊添加一个scope属性，即a的作用域，其值就是第一步中的作用域链，即a.scope=a的作用域链；

然后执行环境会创建一个活动对象。活动对象也拥有一个属性对象，但它不具有原型而且不能通过JavaScript直接访问。创建完活动对象后，把活动对象添加到a的作用域链的最顶端。此时a的作用域链包含两个对象：a的活动对象和window对象；

下一步是在活动对象上添加一个arguments属性，它保存着调用函数a时所传递的参数。

最后把所有函数a的形参和内部的函数b的引用也添加到a的活动对象上。在这一步中，完成了函数b的定义，因此如同第三步，函数b的作用域链被设置为b所被定义的环境，即a的作用域。

到此，整个函数a从定义到执行的步骤就完成了。此时a返回函数b的引用给c，又函数b的作用域链包含了对函数a的活动对象的引用，也就是说b可以访问到a中定义的所有变量和函数。函数b被c引用，函数b有依赖于函数a，因此函数a在返回后不会被GC收购。

三、闭包函数的作用：

1.匿名执行函数

我们知道所有的变量，如果不加上var关键字，则默认的会添加到全局对象的属性上去，这样的临时变量加入全局对象会有很多坏处，比如：别的变量可能会无用这些变量，造成全局对象过于庞大，影响访问速度（因为变量的取值需要从原型链上遍历）。

除了每次使用变量都用var关键字外，我们在实际的使用情况中也会遇到这样一种情况，即有的函数只执行一次，其内部变量无需维护。比如UI的初始化，我们可以使用闭包：

var datamodel = {    
    table : [],    
    tree : {}    
};    
     
(function(dm){    
    for(var i = 0; i < dm.table.rows; i++){    
       var row = dm.table.rows[i];    
       for(var j = 0; j < row.cells; i++){    
           drawCell(i, j);    
       }    
    }    
       
    //build dm.tree      
})(datamodel); 

 上诉代码中创建了一个匿名函数，并立即执行，由于外部无法引用它的内部变量，因此在执行完后很快就会被释放，关键是这种机制不会污染全局对象。

2.缓存

如果我们有一个处理过程很耗时的函数对象，每次调用都需要花费很长时间，那么我们就会将计算出来的值存储起来，当调用这个函数的时候，首先在缓存中查找，如果找不到，则进行计算，然后更新缓存并返回值，如果找到了，直接返回查找到的值即可。闭包正是可以做到这一点，因此它不会释放外部的引用，从而函数内部的值可以得到保留。

    var CachedSearchBox = (function(){    
        var cache = {},    
           count = [];    
        return {    
           attachSearchBox : function(dsid){    
               if(dsid in cache){//如果结果在缓存中    
                  return cache[dsid];//直接返回缓存中的对象    
               }    
               var fsb = new uikit.webctrl.SearchBox(dsid);//新建    
               cache[dsid] = fsb;//更新缓存    
               if(count.length > 100){//保正缓存的大小<=100    
                  delete cache[count.shift()];    
               }    
               return fsb;          
           },    
         
           clearSearchBox : function(dsid){    
               if(dsid in cache){    
                  cache[dsid].clearSelection();      
               }    
           }    
        };    
    })();    
         
    CachedSearchBox.attachSearchBox("input1");    

 这样，当我们第二次调用CachedSearchBox.attachSerachBox(“input1”)的时候，
我们就可以从缓存中取道该对象，而不用再去创建一个新的searchbox对象。

3.实现封装

在函数外部是无法访问其内部变量的，但可以通过闭包的形式来访问。

    var person = function(){    
        //变量作用域为函数内部，外部无法访问    
        var name = "default";       
           
        return {    
           getName : function(){    
               return name;    
           },    
           setName : function(newName){    
               name = newName;    
           }    
        }    
    }();    
         
    print(person.name);//直接访问，结果为undefined    
    print(person.getName());    
    person.setName("abruzzi");    
    print(person.getName());    
       
    得到结果如下：  
       
    undefined  
    default  
    abruzzi  

 4.实现面向对象的对象

传统的对象语言都提供类的模板机制，这样不同的对象（类的实例）拥有独立的成员及状态，互不干涉，虽然JavaScript中没有类这样的机制，但可以通过闭包，我们可以模拟出这样的机制。

    function Person(){    
        var name = "default";       
           
        return {    
           getName : function(){    
               return name;    
           },    
           setName : function(newName){    
               name = newName;    
           }    
        }    
    };    
         
         
    var john = Person();    
    print(john.getName());    
    john.setName("john");    
    print(john.getName());    
         
    var jack = Person();    
    print(jack.getName());    
    jack.setName("jack");    
    print(jack.getName());    
       
    运行结果如下：  
       
    default  
    john  
    default  
    jack  

 上述代码中，john和jack都可以称为是Person这个类的实例，因为这两个实例对name这个成员的访问是独立的，互不影响的。

四、JavaScript的垃圾回收机制

在JavaScript中，如果一个对象不再被引用，那么这个对象就会被GC回收。如果两个对象互相引用，而不再被第三者所引用，那么这两个互相引用的对象也会被回收。

 

闭包是JavaScript中的高级应用，也是迈向高级JS程序员的必经之路，理解了其解释和运行机制才能写出更为安全和优雅的代码。