摘要：函數(shù)作用域要理解閉包，必須從理解函數(shù)被調用時都會發(fā)生什么入手?？梢哉f，閉包是函數(shù)作用域的副產品。無論通過何種手段將內部函數(shù)傳遞到所在的詞法作用域以外，它都會持有對原始定義作用域的引用，無論在何處執(zhí)行這個函數(shù)都會使用閉包。

要理解閉包，必須從理解函數(shù)被調用時都會發(fā)生什么入手。

我們知道，每個javascript函數(shù)都是一個對象，其中有一些屬性我們可以訪問到，有一些不可以訪問，這些屬性僅供JavaScript引擎存取，是隱式屬性。[[scope]]就是其中一個。
[[scope]]就是我們所說的作用域，其中存儲了執(zhí)行期上下文的集合。由于這個集合呈鏈式鏈接，我們把這種鏈式鏈接叫做作用域鏈。

當函數(shù)被定義（創(chuàng)建）時有一個自己所在環(huán)境的作用域（GO全局作用域 ，若是在函數(shù)內部，就是引用別人的作用域），當函數(shù)被執(zhí)行時，會將自己的獨一無二的AO（活動對象，是使用arguments和該函數(shù)內部的變量值初始化的活動對象）執(zhí)行上下文放在前端，形成一個作用域鏈；當該函數(shù)執(zhí)行完，自己的AO會被干掉，回到被定義時的狀態(tài)。

另外，變量的查找，就是找所在函數(shù)的作用域，首先從作用域的頂端開始查找，找不到的情況下，會查找外部函數(shù)的活動對象，依次向下查找，直到到達作為作用域鏈終點的全局執(zhí)行環(huán)境。

下面看幾個查找變量例子，深入理解函數(shù)作用域及作用域鏈。

function a(){
   function b(){
      var b=2223;  
   }
   var a=78;
}
a()
b()
console.log(b)

輸出結果： error: b is not defined
當函數(shù)a執(zhí)行完畢后，該函數(shù)內部的活動對象AO就會被銷毀。所以函數(shù)外部是訪問不到函數(shù)內部的變量的。

function outer(){
   function inner(){
      var b=2223;   
      a=0
   }
   var a=78;
   inner() //①
   console.log(a) 
   console.log(b)
}
outer() 

輸出結果: 0 , error: b is not defined

當函數(shù)inner在被定義的階段，就會擁有（引用）函數(shù)outer的作用域（包括函數(shù)outer自己局部的活動對象AO和全局作用域）；當函數(shù)inner()被執(zhí)行的時候，會再創(chuàng)建一個自己的活動對象AO并被推入執(zhí)行環(huán)境作用域鏈的前端。
inner()函數(shù)在被執(zhí)行的時候，由于變量a在outer()函數(shù)中已經(jīng)存在并被inner()引用，所以inner()函數(shù)內部的變量a會修改掉外部函數(shù)變量a的值，并且可以不用聲明。當inner()函數(shù)執(zhí)行完畢后（執(zhí)行到①處），inner()函數(shù)局部的AO會被銷毀，下面就訪問不到變量b了，而且這時候變量a的值將是被inner()函數(shù)修改過的值。

function a(){
  function b(){
     var b=2223;   
     a=0
  }
  var a=78;
  b=1
  b()
  console.log(b)
}
a()

輸出結果： 1

var x=10;
function a(){
    console.log(x);
}
function b(){
    var x=20;
    a();
}
a();//10
b();//還是10;

總之：函數(shù)在被定義階段，會引用著其所在環(huán)境的作用域；執(zhí)行階段，會創(chuàng)建一個自己獨一無二的活動對象AO，并推入執(zhí)行環(huán)境作用域鏈的前端；函數(shù)執(zhí)行完畢之后，自己的執(zhí)行上下文AO會被銷毀，所以，這時候訪問其內部的變量是訪問不到的。但是，閉包的情況又有不同。

閉包：有權訪問另一個函數(shù)作用域中的變量的函數(shù)。

從理論的角度上，所有的JavaScript函數(shù)都是閉包，因為函數(shù)在被定義階段就會存儲一個自己所在環(huán)境的作用域，可以訪問這個作用域中的所有變量?？梢哉f，閉包是 JS 函數(shù)作用域的副產品。理解js作用域，自然就明白了閉包，即使你不知道那是閉包。

從技術實踐的角度，以下函數(shù)才算閉包：

定義該函數(shù)的執(zhí)行環(huán)境的作用域（執(zhí)行上下文）即使被銷毀 ，它的活動對象（AO）仍然會留在內存中，被該函數(shù)引用著。

引用了函數(shù)體外部的變量。

創(chuàng)建閉包常見方式，就是在一個函數(shù)A內部創(chuàng)建另一個函數(shù)B，然后通過return這個函數(shù)B以便在外部使用，這個函數(shù)B就是一個閉包。

舉個例子：

//也算閉包
var a = 1;
function foo() {
    console.log(a);
}
foo();

//函數(shù)內部定義函數(shù)
var scope = "global scope";
function checkscope(){
    var scope = "local scope";
    function f(){
        return scope;
    }
    return f;
}
checkscope()()  //這里相當于：
//var foo = checkscope();
//foo();

輸出結果：local scope
f()函數(shù)在被定義階段就被保存到了外部，這個時候就相當于外部的函數(shù)可以訪問另一個函數(shù)內部的變量，f()函數(shù)會形成一個閉包。

按照函數(shù)作用域的概念，當checkscope()執(zhí)行完畢后，其局部的活動對象AO會被銷毀；但是由于checkscope()函數(shù)執(zhí)行完畢后返回一個函數(shù)，根據(jù)函數(shù)在被定義階段會引用該函數(shù)所在執(zhí)行環(huán)境的執(zhí)行上下文，被返回的函數(shù)f()即使被保存到了外部依然引用著checkscope()函數(shù)的執(zhí)行期上下文，直到函數(shù)f()執(zhí)行完畢，checkscope()函數(shù)的執(zhí)行上下文才會被銷毀。

也就是說被嵌套的函數(shù)f()無論在什么地方執(zhí)行，都會包含著外部函數(shù)（定義該函數(shù)）的活動對象。所以，即使f()被保存到外部，也可以訪問到另一個函數(shù)checkscope()中定義的變量。

無論通過何種手段將內部函數(shù)傳遞到所在的詞法作用域以外， 它都會持有對原始定義作用域的引用， 無論在何處執(zhí)行這個函數(shù)都會使用閉包。

由此看來，閉包可能會導致一個問題：導致原有作用域鏈不釋放，造成內存泄漏（內存空間越來越少）。可以通過手動將被引用的函數(shù)設為null，來解除對該函數(shù)的引用，以便釋放內存。

實現(xiàn)公有變量。

function a(){
   var num=100;
   function b(){
      num++;
      console.log(num)
   }
   return b;
}

var demo=a();
demo();//101
demo();//102

function test(){
   var num=100;
   function a(){
      num++;
   }
   function b(){
      num--;
   }
   return [a,b]

}

var demo=test()
demo[0]();//101
demo[1]();//100
//函數(shù)a和函數(shù)b引用的是同一個作用域。

實現(xiàn)私有變量。

閉包通常用來創(chuàng)建內部變量，使得這些變量不能被外部隨意修改，同時又可以通過指定的函數(shù)接口來操作。
通過在立即執(zhí)行函數(shù)中return 將方法保存到外部等待調用，內部的變量由于是私有的，外部訪問不到，可防止污染全局變量，利于模塊化開發(fā)。

var foo = ( function() { 
   var secret = "secret"; 
   // “閉包”內的函數(shù)可以訪問 secret 變量，而secret變量對于外部卻是隱藏的 
   return { 
      get_secret: function () { 
         // 通過定義的接口來訪問 secret 
            return secret; 
      }, 
      new_secret: function ( new_secret ) { 
         // 通過定義的接口來修改 secret 
         secret = new_secret; 
      } 
   }; 
} () ); 
foo.get_secret (); // 得到 "secret" 
foo.secret; // undefined，訪問不能 
foo.new_secret ("a new secret"); // 通過函數(shù)接口，我們訪問并修改了secret 變量 
foo.get_secret (); // 得到 "a new secret"

var name="bcd";
var init=(function (){
   var name="abc";
   function callName(){
      console.log(name);
   }

   //其他方法

   return function () {
      callName();
      //其他方法
   }
}())

init () //abc

function createFunctions(){
  var result = new Array();
  for (var i=0; i < 10; i++){
    result[i] = function(){
      console.log(i);
     };
  }
return result;
}

var fun = createFunctions();
for(var i=0;i<10;i++){
    fun[i]();
}

輸出結果：打印十個10
數(shù)組每個值都是一個函數(shù)，每個函數(shù)對createFunctions()形成一個閉包，此時i都是引用createFunctions()中同一個i變量。

function test(){
   var arr=[];
   for(var i=0;i<10;i++){
      (function(j){
         arr[j]=function(){
            console.log(j);
         }
      }(i))
   }
   console.log(i)//10 ，i還是10
   return arr
}
var myArr=test();
for(var i=0;i<10;i++){
   myArr[i]()
}

輸出結果：從0到9
這次依然把數(shù)組每個值賦為函數(shù)，不同的是循環(huán)十次立即執(zhí)行函數(shù)，并將當前循環(huán)的i作為參數(shù)傳進立即執(zhí)行函數(shù)，由于參數(shù)是按值傳遞的，這樣就把當前循環(huán)的i保存下來了。

在閉包中使用this對象可能會導致一些問題，結果往往不是預想的輸出結果。
看個例子：

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

輸出結果：The Window

this對象是在運行時基于函數(shù)的執(zhí)行環(huán)境綁定的：在全局函數(shù)中，this等于window，而當函數(shù)被作為某個對象的方法調用時，this等于那個對象。匿名函數(shù)往往具有全局性，這里可以這樣理解，沒有任何對象調用這個匿名函數(shù)，雖然這個匿名函數(shù)擁有getNameFunc()的執(zhí)行上下文。

因為這個匿名函數(shù)擁有getNameFunc()的執(zhí)行上下文，通過把外部函數(shù)getNameFunc()作用域中的this對象保存在一個閉包能夠訪問到的變量里，就可以讓閉包訪問到該對象了。

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

輸出結果：My Object

理解到這里，基本上就搞定了閉包了。

JavaScript 里的閉包是什么？應用場景有哪些？