這篇文章主要介紹了js閉包的相關知識，閉包是Javascript的一個難點，但也是一個很重要的知識點,需要的朋友可以參考下

1、首先我們要知道變量作用域鏈

變量的作用域分兩種：全局變量和局部變量。沒有定義到任何函數中的變量為全局變量，在函數中定義的變量為局部變量，注意在函數內部定義變量時一定要使用var關鍵字，不帶var關鍵字的變量為全局變量。

javascript中每一段代碼都有與之關聯的作用域鏈，這個作用域鏈是一個對象列表或者鏈表，定義了這段代碼“作用域”中的變量。頂層代碼的作用域由全局變量組成;不包含嵌套的函數的作用域鏈有兩個對象：一個是定義的函數參數和局部變量的對象，一個是全局變量對象;而嵌套函數的作用域鏈有三個對象：函數參數和局部變量--外部函數的參數和局部變量--全局變量。函數可以訪問作用域鏈上的對象，因此函數可以訪問全局變量，而反過來卻不可以，即在函數外部不能訪問函數內的局部變量。

1. var a=1; 
2. function wai(){ 
3. alert(a);  
4. var m=10; 
5. n=20; 
6. } 
7.  
8. wai(); //=> 1; 函數內部可以訪問全局變量 
9. alert(m); //=> error; 外部訪問函數局部變量報錯  
10. alert(n); //=> 20; 函數內部定義的變量未使用var關鍵字，所以是全局變量，外部可以訪問 

2、如何在外部讀取局部變量

有時候，我們需要在外部訪問函數內板的局部變量，這個時候我們就需要使用變通的方法來實現。我們利用javascript變量作用域的特點，在函數內部定義子函數，子函數就可以訪問父函數里的變量了

1. function wai(){ 
2. var m=10; 
3. function nei(){ 
4. alert(m);  
5. } 
6. return nei; 
7. } 
8.  
9. var f = wai(); 
10. nei(); //=> error; nei()函數是一個局部變量，在外部不能訪問 
11. f(); //=> 10; 

3、閉包

上一段代碼的nei()函數就是一個閉包，從上面可知，閉包就是可以讀取函數內部局部變量的函數，是定義到函數內部的函數，本質上可以認為是函數內部和函數外部連接到一起的橋梁。

閉包的作用有兩個：

一是前面提到的可以讀取函數內部的變量

二是可以讓這些局部變量保存在內存中，實現變量數據共享

1. function wai(){ 
2. var m=99; 
3. function nei(){ 
4. alert(m); 
5. m++; 
6. } 
7. return nei; 
8. } 
9.  
10. var f= wai(); 
11. f(); //=> 99; 
12. f(); //=> 100; 
13. f(); //=> 101; 

上述實例當wai()函數運行時，變量m就保存到內存中，執行f()就可以讀取m的值，但直接alert(m)不可以!

我們還可以向閉包函數傳參數，如下面示例所示，定義一個匿名函數并返回了一個閉包函數，該函數將傳入的參數與匿名函數中的局部變量i相加，并使i自增;

1. var wai=(function(){ 
2. var i=0; 
3. return function(num){ 
4. num+=i; 
5. alert(num); 
6. i++; 
7. } 
8. })(); 
9. wai(1);//1 
10. wai(2);//3 
11. wai(3);//5 

為了更深入理解閉包，我們看下面一個示例：

現在我想定義一個函數，該函數返回一個數組，且數組每個元素都是一個函數，每個函數會彈出對應的索引值

我們可能會這樣寫

1. function box(){ 
2. var arr=[]; 
3. for(i=0;i<5;i++){ 
4. arr[i]=function(){return i;} 
5. } 
6. return arr;  
7. } 
8. var a=box(); 
9. alert(a); //=>包含五個函數體的數組 
10. alert(a[0]()); //=> 5; 
11. alert(a[1]()); //=> 5; 

上面的代碼發現彈出的都是5，而不是我們預想的0,1,2,3,4，這是因為i也是存在于內存中的局部變量，當我們運行a[0]()時，i的值已經是5，i的值在整個box()函數運行過程中是不斷自增的。

解決方法：閉包的實現

1. function box(){ 
2. var arr=[]; 
3. for(var i=0;i<5;i++){ 
4.  
5. arr[i]=(function(num){ 
6. return function(){return num;} 
7. })(i); 
8.  
9. } 
10. return arr;  
11. } 
12.  
13. var arr=box(); 
14.  
15. for(var i=0;i<5;i++){ 
16.  
17. alert(arr[i]());//0,1,2,3,4 
18. } 

4、使用閉包的注意事項

1)由于閉包會使得函數中的變量都被保存在內存中，內存消耗很大，所以不能濫用閉包，否則會造成網頁的性能問題，在IE中可能導致內存泄露。解決方法是，在退出函數之前，將不使用的局部變量全部刪除。

2)閉包會在父函數外部，改變父函數內部變量的值。所以，如果你把父函數當作對象(object)使用，把閉包當作它的公用方法(Public Method)，把內部變量當作它的私有屬性(private value)，這時一定要小心，不要隨便改變父函數的變量值。

5、下面是從幾個關于閉包的思考題

如果你能理解下面代碼的運行結果，應該就算理解閉包的運行機制了。

Js代碼

1. var name = "The Window";  
2. var object = {  
3. name : "My Object",  
4. getNameFunc : function(){  
5. return function(){  
6. return this.name; //=>嵌套函數的this為全局變量或undefined，不會繼承父函數的this 
7. };  
8. }  
9. };  
10. alert(object.getNameFunc()()); //The Window 

以上之所以輸出的為“The window”是因為在嵌套函數中this不會繼承父函數this，其值為全局變量或undefined(ECMAScript5下)，因此返回的為全局對象的name變量。要想讓其返回object的name屬性，代碼如下：

1. var name = "The Window";  
2. var object = {  
3. name : "My Object",  
4. getNameFunc : function(){  
5. var cur=this; 
6. return function(){  
7. return cur.name; 
8. };  
9. }  
10. };  
11. alert(object.getNameFunc()()); //=》My Object 

以上代碼將父函數object的this賦給cur變量，其嵌套函數就可以通過cur變量訪問其屬性了

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

JavaScript閉包例子

1. function outerFun() 
2. { 
3. var a=0; 
4. function innerFun() 
5. { 
6. a++; 
7. alert(a); 
8. }  
9. } 
10. innerFun(); //=>error 

上面的代碼是錯誤的.innerFun()的作用域在outerFun()內部,所在outerFun()外部調用它是錯誤的.

改成如下,也就是閉包:

Js代碼

1. function outerFun() 
2. { 
3. var a=0; 
4. function innerFun() 
5. { 
6. a++; 
7. alert(a); 
8. } 
9. return innerFun; //注意這里 
10. } 
11. var obj=outerFun(); 
12. obj(); //結果為1 
13. obj(); //結果為2 
14. var obj2=outerFun(); 
15. obj2(); //結果為1 
16. obj2(); //結果為2 

什么是閉包:

當內部函數 在定義它的作用域 的外部 被引用時,就創建了該內部函數的閉包 ,如果內部函數引用了位于外部函數的變量,當外部函數調用完畢后,這些變量在內存不會被 釋放,因為閉包需要它們.

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

再來看一個例子

Js代碼

1. function outerFun() 
2. { 
3. var a =0; 
4. alert(a);  
5. } 
6. var a=4; 
7. outerFun(); //=> 0 
8. alert(a); //=> 4 

結果是 0,4 . 因為在函數內部使用了var關鍵字 維護a的作用域在outFun()內部.

再看下面的代碼:

Js代碼

1. function outerFun() 
2. { 
3. //沒有var  
4. a =0; 
5. alert(a);  
6. } 
7. var a=4; 
8. outerFun(); //=> 0 
9. alert(a); //=> 0 

結果為 0,0 真是奇怪,為什么呢?

作用域鏈是描述一種路徑的術語,沿著該路徑可以確定變量的值 .當執行a=0時,因為沒有使用var關鍵字,因此賦值操作會沿著作用域鏈到var a=4; 并改變其值.