闭包

闭包

闭包有两个作用：
第一个就是可以读取自身函数外部的变量（沿着作用域链寻找）
第二个就是让这些外部变量始终保存在内存中
关于第二点，来看一下以下的代码：

  function outer(){
     var result = new Array();
     for(var i = 0; i < 2; i++){//注：i是outer()的局部变量
        result[i] = function(){
           return i;
        }
     }
     return result;//返回一个函数对象数组
     //这个时候会初始化result.length个关于内部函数的作用域链
  }
  var fn = outer();
  console.log(fn[0]());//result：2
  console.log(fn[1]());//result：2

返回结果很出乎意料吧，你肯定以为依次返回0，1，但事实并非如此
来看一下调用fn0的作用域链图：

可以看到result[0]函数的活动对象里并没有定义i这个变量，于是沿着作用域链去找i变量，结果在父函数outer的活动对象里找到变量i(值为2)，而这个变量i是父函数执行结束后将最终值保存在内存里的结果。
由此也可以得出，js函数内的变量值不是在编译的时候就确定的，而是等在运行时期再去寻找的。

那怎么才能让result数组函数返回我们所期望的值呢？
看一下result的活动对象里有一个arguments，arguments对象是一个参数的集合，是用来保存对象的。
那么我们就可以把i当成参数传进去，这样一调用函数生成的活动对象内的arguments就有当前i的副本。
改进之后：

  function outer(){
     var result = new Array();
     for(var i = 0; i < 2; i++){
        //定义一个带参函数
        function arg(num){
           return num;
        }
        //把i当成参数传进去
        result[i] = arg(i);
     }
     return result;
  }
  var fn = outer();
  console.log(fn[0]);//result:0
  console.log(fn[1]);//result:1

虽然的到了期望的结果，但是又有人问这算闭包吗？调用内部函数的时候，父函数的环境变量还没被销毁呢，而且result返回的是一个整型数组，而不是一个函数数组！
确实如此，那就让arg(num)函数内部再定义一个内部函数就好了：
这样result返回的其实是innerarg()函数

  function outer(){
     var result = new Array();
     for(var i = 0; i < 2; i++){
        //定义一个带参函数
        function arg(num){
           function innerarg(){
              return num;
           }
           return innerarg;
        }
        //把i当成参数传进去
        result[i] = arg(i);
     }
     return result;
  }
  var fn = outer();
  console.log(fn[0]());
  console.log(fn[1]());

当调用outer，for循环内i=0时的作用域链图如下：

由上图可知，当调用innerarg()时，它会沿作用域链找到父函数arg()活动对象里的arguments参数num=0.
上面代码中，函数arg在outer函数内预先被调用执行了，对于这种方法，js有一种简洁的写法：

​ function outer(){
var result = new Array();
for(var i = 0; i < 2; i++){
//定义一个带参函数
result[i] = function(num){
function innerarg(){
return num;
}
return innerarg;
}(i);//预先执行函数写法
//把i当成参数传进去
}
return result;
}