函數(shù)作用域
要理解閉包，必須從理解函數(shù)被調(diào)用時都會發(fā)生什么入手。
我們知道，每個javascript函數(shù)都是一個對象，其中有一些屬性我們可以訪問到，有一些不可以訪問，這些屬性僅供JavaScript引擎存取，是隱式屬性。[[scope]]就是其中一個。
[[scope]]就是我們所說的作用域，其中存儲了執(zhí)行期上下文的集合。由于這個集合呈鏈式鏈接，我們把這種鏈式鏈接叫做作用域鏈。
當(dāng)函數(shù)被定義（創(chuàng)建）時有一個自己所在環(huán)境的作用域（GO全局作用域 ，若是在函數(shù)內(nèi)部，就是引用別人的作用域），當(dāng)函數(shù)被執(zhí)行時，會將自己的獨一無二的AO（活動對象，是使用arguments和該函數(shù)內(nèi)部的變量值初始化的活動對象）執(zhí)行上下文放在前端，形成一個作用域鏈；當(dāng)該函數(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)
輸出結(jié)果： error: b is not defined
當(dāng)函數(shù)a執(zhí)行完畢后，該函數(shù)內(nèi)部的活動對象AO就會被銷毀。所以函數(shù)外部是訪問不到函數(shù)內(nèi)部的變量的。
function outer(){
function inner(){
var b=2223;
a=0
}
var a=78;
inner() //①
console.log(a)
console.log(b)
}
outer()
輸出結(jié)果: 0 , error: b is not defined
當(dāng)函數(shù)inner在被定義的階段，就會擁有（引用）函數(shù)outer的作用域（包括函數(shù)outer自己局部的活動對象AO和全局作用域）；當(dāng)函數(shù)inner()被執(zhí)行的時候，會再創(chuàng)建一個自己的活動對象AO并被推入執(zhí)行環(huán)境作用域鏈的前端。
inner()函數(shù)在被執(zhí)行的時候，由于變量a在outer()函數(shù)中已經(jīng)存在并被inner()引用，所以inner()函數(shù)內(nèi)部的變量a會修改掉外部函數(shù)變量a的值，并且可以不用聲明。當(dāng)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()
輸出結(jié)果： 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會被銷毀，所以，這時候訪問其內(nèi)部的變量是訪問不到的。但是，閉包的情況又有不同。
簡述什么是閉包
閉包：有權(quán)訪問另一個函數(shù)作用域中的變量的函數(shù)。
從理論的角度上，所有的JavaScript函數(shù)都是閉包，因為函數(shù)在被定義階段就會存儲一個自己所在環(huán)境的作用域，可以訪問這個作用域中的所有變量。可以說，閉包是 JS 函數(shù)作用域的副產(chǎn)品。理解js作用域，自然就明白了閉包，即使你不知道那是閉包。
從技術(shù)實踐的角度，以下函數(shù)才算閉包：
- 定義該函數(shù)的執(zhí)行環(huán)境的作用域（執(zhí)行上下文）即使被銷毀 ，它的活動對象（AO）仍然會留在內(nèi)存中，被該函數(shù)引用著。
- 引用了函數(shù)體外部的變量。
創(chuàng)建閉包常見方式，就是在一個函數(shù)A內(nèi)部創(chuàng)建另一個函數(shù)B，然后通過return這個函數(shù)B以便在外部使用，這個函數(shù)B就是一個閉包。
舉個例子：
//也算閉包
var a = 1;
function foo() {
console.log(a);
}
foo();
//函數(shù)內(nèi)部定義函數(shù)
var scope = "global scope";
function checkscope(){
var scope = "local scope";
function f(){
return scope;
}
return f;
}
checkscope()() //這里相當(dāng)于：
//var foo = checkscope();
//foo();
輸出結(jié)果：local scope
f()函數(shù)在被定義階段就被保存到了外部，這個時候就相當(dāng)于外部的函數(shù)可以訪問另一個函數(shù)內(nèi)部的變量，f()函數(shù)會形成一個閉包。
按照函數(shù)作用域的概念，當(dāng)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()中定義的變量。
無論通過何種手段將內(nèi)部函數(shù)傳遞到所在的詞法作用域以外， 它都會持有對原始定義作用域的引用， 無論在何處執(zhí)行這個函數(shù)都會使用閉包。
由此看來，閉包可能會導(dǎo)致一個問題：導(dǎo)致原有作用域鏈不釋放，造成內(nèi)存泄漏（內(nèi)存空間越來越少）。可以通過手動將被引用的函數(shù)設(shè)為null，來解除對該函數(shù)的引用，以便釋放內(nèi)存。
閉包的作用
- 實現(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)建內(nèi)部變量，使得這些變量不能被外部隨意修改，同時又可以通過指定的函數(shù)接口來操作。
通過在立即執(zhí)行函數(shù)中return 將方法保存到外部等待調(diào)用，內(nèi)部的變量由于是私有的，外部訪問不到，可防止污染全局變量，利于模塊化開發(fā)。
var foo = ( function() {
var secret = 'secret';
// “閉包”內(nèi)的函數(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
閉包經(jīng)典題
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]();
}
輸出結(jié)果：打印十個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]()
}
輸出結(jié)果：從0到9
這次依然把數(shù)組每個值賦為函數(shù)，不同的是循環(huán)十次立即執(zhí)行函數(shù)，并將當(dāng)前循環(huán)的i作為參數(shù)傳進立即執(zhí)行函數(shù)，由于參數(shù)是按值傳遞的，這樣就把當(dāng)前循環(huán)的i保存下來了。
閉包中的this對象
在閉包中使用this對象可能會導(dǎo)致一些問題，結(jié)果往往不是預(yù)想的輸出結(jié)果。
看個例子：
var name = "The Window";
var object = {
name : "My Object",
getNameFunc : function(){
return function(){
return this.name;
};
}
};
alert(object.getNameFunc()());
輸出結(jié)果：The Window
this對象是在運行時基于函數(shù)的執(zhí)行環(huán)境綁定的：在全局函數(shù)中，this等于window，而當(dāng)函數(shù)被作為某個對象的方法調(diào)用時，this等于那個對象。匿名函數(shù)往往具有全局性，這里可以這樣理解，沒有任何對象調(diào)用這個匿名函數(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()());
輸出結(jié)果：My Object
理解到這里，基本上就搞定了閉包了。
