javascript闭包的理解

闭包是Javascript的一个难点，但也是一个很重要的知识点。

一、首先咱们要知道变量做用域链

变量的做用域分两种：全局变量和局部变量。没有定义到任何函数中的变量为全局变量，在函数中定义的变量为局部变量，注意在函数内部定义变量时必定要使用var关键字，不带var关键字的变量为全局变量。

javascript中每一段代码都有与之关联的做用域链，这个做用域链是一个对象列表或者链表，定义了这段代码“做用域”中的变量。顶层代码的做用域由全局变量组成；不包含嵌套的函数的做用域链有两个对象：一个是定义的函数参数和局部变量的对象，一个是全局变量对象；而嵌套函数的做用域链有三个对象：函数参数和局部变量--外部函数的参数和局部变量--全局变量。函数能够访问做用域链上的对象，所以函数能够访问全局变量，而反过来却不能够，即在函数外部不能访问函数内的局部变量。

var a=1;
function wai(){
   alert(a);                
   var m=10;
   n=20;
}

wai();                    //=> 1;  函数内部能够访问全局变量
alert(m);               //=> error; 外部访问函数局部变量报错   
alert(n);               //=>  20;  函数内部定义的变量未使用var关键字，因此是全局变量，外部能够访问

二、如何在外部读取局部变量

有时候，咱们须要在外部访问函数内板的局部变量，这个时候咱们就须要使用变通的方法来实现。咱们利用javascript变量做用域的特色，在函数内部定义子函数，子函数就能够访问父函数里的变量了

function wai(){
  var m=10;
   function nei(){
        alert(m);  
  }
   return nei;
}

var f = wai();
nei();                           //=>  error;  nei()函数是一个局部变量，在外部不能访问
f();                             //=>  10;

三、闭包

上一段代码的nei()函数就是一个闭包，从上面可知，闭包就是能够读取函数内部局部变量的函数，是定义到函数内部的函数，本质上能够认为是函数内部和函数外部链接到一块儿的桥梁。

闭包的做用有两个：

一是前面提到的能够读取函数内部的变量

二是可让这些局部变量保存在内存中，实现变量数据共享

function wai(){
    var m=99;
    function nei(){
        alert(m);
        m++;
    }
    return nei;
}
            
var f= wai();
f();                  //=>  99;
f();                  //=> 100;
f();                  //=> 101;

上述实例当wai()函数运行时，变量m就保存到内存中，执行f()就能够读取m的值，但直接alert(m)不能够!

咱们还能够向闭包函数传参数，以下面示例所示，定义一个匿名函数并返回了一个闭包函数，该函数将传入的参数与匿名函数中的局部变量i相加，并使i自增；

var wai=(function(){
    var i=0;
    return function(num){
        num+=i;
       alert(num);
        i++;
  }
})();
wai(1);//1
wai(2);//3
wai(3);//5

为了更深刻理解闭包，咱们看下面一个示例：

如今我想定义一个函数，该函数返回一个数组，且数组每一个元素都是一个函数，每一个函数会弹出对应的索引值

咱们可能会这样写

function box(){
  var arr=[];
   for(i=0;i<5;i++){
       arr[i]=function(){return i;}
    }
  return arr;   
}
var a=box();
alert(a);                //=>包含五个函数体的数组
alert(a[0]());         //=> 5;
alert(a[1]());        //=>  5;

上面的代码发现弹出的都是5，而不是咱们预想的0,1,2,3,4，这是由于i也是存在于内存中的局部变量，当咱们运行a[0]()时，i的值已是5，i的值在整个box()函数运行过程当中是不断自增的。

解决方法：闭包的实现

function box(){
var arr=[];
        for(var i=0;i<5;i++){

                 arr[i]=(function(num){
                     return function(){return num;}
                 })(i);

         }
return arr;         
}

var arr=box();

for(var i=0;i<5;i++){

    alert(arr[i]());//0,1,2,3,4
}

四、使用闭包的注意事项

1）因为闭包会使得函数中的变量都被保存在内存中，内存消耗很大，因此不能滥用闭包，不然会形成网页的性能问题，在IE中可能致使内存泄露。解决方法是，在退出函数以前，将不使用的局部变量所有删除。

2）闭包会在父函数外部，改变父函数内部变量的值。因此，若是你把父函数看成对象（object）使用，把闭包看成它的公用方法（Public Method），把内部变量看成它的私有属性（private value），这时必定要当心，不要随便改变父函数的变量值。

 

五、下面是几个关于闭包的思考题

若是你能理解下面代码的运行结果，应该就算理解闭包的运行机制了。

Js代码 

var name = "The Window"; 
var object = { 
    name : "My Object", 
    getNameFunc : function(){ 
       return function(){ 
           return this.name;              //=>嵌套函数的this为全局变量或undefined，不会继承父函数的this
       }; 
   } 
}; 
alert(object.getNameFunc()()); //The Window    

以上之因此输出的为“The window”是由于在嵌套函数中this不会继承父函数this，其值为全局变量或undefined(ECMAScript5下)，所以返回的为全局对象的name变量。要想让其返回object的name属性，代码以下：

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

以上代码将父函数object的this赋给cur变量，其嵌套函数就能够经过cur变量访问其属性了

--------------------------------------------------------------------------------------------------------
JavaScript闭包例子

function outerFun()
{
var a=0;
function innerFun()
{
a++;
alert(a);
} 
}
innerFun();   //=>error

上面的代码是错误的.innerFun()的做用域在outerFun()内部,所在outerFun()外部调用它是错误的.

改为以下,也就是闭包:

Js代码

function outerFun()
{
     var a=0;
    function innerFun()
   {
        a++;
        alert(a);
   }
    return innerFun; //注意这里
}
var obj=outerFun();
obj(); //结果为1
obj(); //结果为2
var obj2=outerFun();
obj2(); //结果为1
obj2(); //结果为2

 

什么是闭包:

当内部函数 在定义它的做用域 的外部 被引用时,就建立了该内部函数的闭包 ,若是内部函数引用了位于外部函数的变量,当外部函数调用完毕后,这些变量在内存不会被 释放,由于闭包须要它们.

--------------------------------------------------------------------------------------------------------

再来看一个例子

Js代码

function outerFun()
{
     var a =0;
     alert(a); 
}
var a=4;
outerFun();      //=>  0
alert(a);           //=>  4

结果是 0,4 . 由于在函数内部使用了var关键字 维护a的做用域在outFun()内部.

再看下面的代码:

Js代码 

function outerFun()
{
//没有var 
a =0;
alert(a); 
}
var a=4;
outerFun();       //=> 0
alert(a);            //=>  0

结果为 0,0 真是奇怪,为何呢?做用域链是描述一种路径的术语,沿着该路径能够肯定变量的值 .当执行a=0时,由于没有使用var关键字,所以赋值操做会沿着做用域链到var a=4; 并改变其值.