一步一步的理解闭包

     一步步的理解闭包：

1. javascript是函数作用域，按常理来说，一个函数就不能访问另一个函数中的变量。
2. 而我们实际操作有时候需要用一个函数去操作另一个函数中的变量。
3. 为了能够访问另一个函数作用域中的变量，javascript提供一种内部机制，给嵌套在其它函数中的函数提供了一种父作用域链保存机制。
4. 当内部函数创建时，静态的保存了父作用域链，即使父函数执行完毕，其变量对象(这里面保存着我们想要的父变量)一直保存在内部函数的作用域链中。内部函数不再被调用之前，这个活动对象一直在内存中(通俗讲就是这时候父函数的变量对象和内部函数绑定在一起了，同生共死)。这种机制取名为闭包。
5. 简洁地说：闭包就是有权访问其他函数作用域变量的函数。

下文的叙述以此图为标准，若有疑问请参照

     下面我们来一些经典实例来进一步帮你解除闭包的困扰(js中最难的一个问题之一)，嵌套函数由于其天然的嵌套形式是闭包最常见的一种表现方式。由嵌套函数开始吧 

 function sayHello2(name){
     var text='hello'+name;
     var sayAlert=function(){alert(text);}
     return sayAlert;
 }
 var say2=sayHello2('jack');
 say2();//hello jack

     上面的代码就是一个嵌套函数，也是我们见过的最常见闭包表现形式，因为匿名函数function(){alert(text);}可以访问到外部函数sayHello2中的text变量，这就形成了闭包。闭包虽然存在了，但它也不能徒有其表，还的做点事情。代码第6行的赋值表达式后，外部函数sayHello2就被销毁了，按常理其内部变量text也随之销毁。可第7行成功的调用说明，外部函数的变量对象始终保留在内存中，直到内部函数销毁，不再被调用为止(总的有个头，不然内存扛不住)。

再看下面的例子

function say667(){
    var num=666;
    var sayAlert=function(){alert(num);}
    num++;
    return sayAlert;
}
var sayNum=say667();
sayNum();//667

     为什么最后是667，不是你期望的666？(有的地方是这样解释的，说是对父变量的引用，而不是复制。笔者认为基本类型不存在引用(地址)这一说吧)。保存着外部函数的活动对象,活动对象就是一个盒子。里面的变量，父函数可以随意改变。

     这个变量对象本来就是父函数的一部分，所以父函数能操作它是理所当然。而这个父变量对象也静态的保存在内部函数的作用域链中，那内部函数应该也有权利去操作它。

function baz(){
    var x=1;
    return {
        foo:function foo(){return ++x;},
        bar:function bar(){return --x;}
            };
}
var closures=baz();
alert(closures.foo(),//2
    closures.bar()//1）

     你会发现内部的foo函数改变了父变量，与此同时也影响到了bar函数的结果。这是为什么？这是因为内部的两个函数在创建的时候都保存的是同一个父作用域—baz的作用域。这样一来父变量对象就是共享的了，所以里面的变量相互影响。(作用域包含变量对象，变量对象包含变量)

     再来看我们遇到过的一个循环问题了，同样是父函数一某种方式改变了这个变量对象中的变量值。使得内部函数最后访问的值变成了循环最终值。

function list(){
    var result=[];
    for(var i=0;i<3;i++){
        result[i]=function(){
            alert(i);
        }
    }
}
result[0];//3
result[1];//3
result[2];//3

闭包的用途

下面看看闭包的用途吧，闭包可以用在许多地方。

1. 基本功能就是前面提到的可以读取函数外部的变量，就不在赘述了。
2. 另一个就是让外部函数变量的值始终保持在内存中(直到不存在这些变量的引用)。

     把你期望的值保存在一个地方，这与缓存的思想不谋而合。例如我们需要处理一个过程很耗时的函数对象，每次调用都会花费很长时间，那么我们需要把计算的值保存起来。调用的时候首先在缓存中查找，如果找不到则进行计算，然后更新缓存的值。如果找到了，直接返回找到的值即可。闭包正是可以做到这一点.

var cacheSearchBox=(function(){
    var cache={}; 
 4     return {
        attachSearchBox:function(boxid){
            if(boxid in cache){
                return cache[boxid];
            }
            var fsb=new searchBox(boxid);
            cache[boxid]=fsb;
            return fsb
        }
    }
})();
cacheSearchBox.attachSearchBox("input1");

     这样，当我们第二次调用cacheSearchBox.attachSearchBox("input1")时，我们可以从缓存中获取该对象，而不用再去创建一个新的searchbox对象。

     3 面向对象中实现特权方法

     在下面的例子中，在person之外的地方无法访问其内部变量。只有通过闭包构造的特权方法的形式来访问。同时实现了私有变量和访问私有变量的特权方法的封装：

var person=function(){
    var name="deng";
    return{
        getName:function(){
            return name;
        },
        setName:function(newName){
            name=newName;
        }
    }
}();
alert(person.name);//undefined
alert(person.getName());//deng
person.setName("jack");
alert(person.getName());//jack

使用闭包的注意点

1）由于闭包会使得函数中的变量都被保存在内存中，内存消耗很大，所以不能滥用闭包，否则会造成网页的性能问题，在IE中可能导致内存泄露。解决方法是，在退出函数之前，将不使用的局部变量全部删除。

2）闭包会在父函数外部，改变父函数内部变量的值。实现面向对象封装中特权方法时，慎重修改私有变量。

文章在上纲上线的同时，加入了很多自己的理解。也许存在纰漏，望探讨。