閉包通常指「有權訪問另一個函數作用域中變量的函數」。它是 JavaScript 裡最容易被談起、卻也最容易被講糊的概念,很多看起來很高級的寫法背後都有它的影子。要真正理解它,得從作用域說起。
function outer() {
var i = 100;
function inner() {
console.log(i);
}
}
按照作用域規則,outer 內部的所有局部變量對 inner 都是可見的;反過來,inner 的局部變量在外部完全不可見。既然 inner 能讀到 outer 的變量,那麼只要把 inner 作為返回值交出去,就能從外部間接讀到它。
function outer() {
var i = 100;
function inner() {
console.log(i);
}
return inner;
}
var rs = outer();
rs();
這段代碼有兩個要點:inner 嵌套在 outer 內部,且 outer 把 inner 返回了出來。執行完 var rs = outer() 之後,rs 實際指向的就是 inner——這就是一個閉包。換句話說,當函數內部的函數被外部變量引用時,閉包便誕生了。
作用域決定變量與函數的可訪問範圍,也就決定了它們的可見性與生命週期。JavaScript 中的作用域分為全局作用域與局部作用域兩種。
var num1 = 1;
function fun1(){ num2 = 2; }
這裡的 num1、num2 和 fun1 都屬於全局作用域。要特別留意:沒有聲明就直接賦值的變量,會自動變成全局變量。
function wrap(){
var obj = "我被 wrap 包裹起來了,外部無法直接訪問";
function innerFun(){
// 外部同樣訪問不到
}
}
再往深一層看作用域鏈。JavaScript 中的函數對象帶有一個 [[Scope]] 屬性,它記錄了函數被創建時所在作用域中的對象集合,這個集合就被稱為作用域鏈(Scope Chain),它決定了函數能訪問到哪些數據。
function add(a,b){ return a+b; }
函數創建時,[[scope]] 會自動包含全局作用域。

var sum = add(3,4);
函數被調用時,還會創建一個稱作運行期上下文(execution context)的內部對象,用來描述函數執行時的環境。它同樣有自己的作用域鏈,初始化為當前函數 [[Scope]] 所包含的對象。

執行過程中每遇到一個變量,都會走一遍標識符解析:從作用域鏈頭部(活動對象)開始查找同名標識符,找到就用,找不到就沿鏈條往下一個對象繼續找;直到鏈條終點(全局對象)仍未命中,才判定該標識符未定義。
var quo = function(status){
return {
getStatus: function(){
return status;
}
}
}
status 保存在 quo 的作用域中,函數返回一個對象,對象裡的 getStatus 引用了這個 status,也就是說 getStatus 訪問了它的外部變量。
var newValue = quo('string');
newValue.getStatus();
假如沒有 getStatus 這個方法,quo('string') 執行結束後 status 就會被回收。而現在返回的匿名對象被全局變量引用著,這個對象又依賴 status,於是 status 的釋放被阻止了。
// 錯誤寫法
var test = function(nodes){
var i;
for(i = 0; i < nodes.length; i++){
nodes[i].onclick = function(e){
alert(i);
}
}
}
匿名函數形成的閉包訪問的是 test 作用域中的同一個 i,因此所有節點綁定的其實都是同一個變量,點擊任何一個都會輸出循環結束後的值。

// 改進寫法
var test = function(nodes){
var i;
for(i = 0; i < nodes.length; i++){
nodes[i].onclick = function(i){
return function(){
alert(i);
};
}(i);
}
}
這裡用了一個立即執行的匿名函數接收參數。由於參數是按值傳遞的,每一輪循環都會為當前的 i 生成一份獨立副本,問題自然消解。

function outer() {
var i = 100;
function inner() {
console.log(i++);
}
return inner;
}
var rs = outer();
rs(); // 100
rs(); // 101
rs(); // 102
rs 就是閉包 inner。連續執行三次,輸出依次遞增,說明 outer 的局部變量 i 一直留在內存中,並沒有在函數調用結束後被清掉。
閉包的價值正在於此:outer 執行完畢並返回後,由於內部函數 inner 的執行仍依賴 outer 的變量,垃圾回收機制不會回收 outer 所占用的內存。(另一種解釋是:inner 被賦給了全局變量而長存,inner 的存在又依賴 outer,於是 outer 也一起留在內存中。)換言之,函數返回閉包之後,它的作用域會一直保存到閉包不再存在為止。
function f() {
var rs = [];
for (var i=0; i < 10; i++) {
rs[i] = function() { return i; };
}
return rs;
}
var fn = f();
for (var i = 0; i < fn.length; i++) {
console.log('函數 fn[' + i + ']() 返回值:' + fn[i]());
}
表面上每個函數都該返回自己的索引,實際上全部返回 10。原因就在作用域鏈:每個函數的鏈上都保存著 f 的活動對象,引用的都是同一個 i;f 返回時 i 已經是 10。
用一個立即執行的匿名函數就能糾正這個行為:
function f() {
var rs = [];
for (var i=0; i < 10; i++) {
rs[i] = function(num) {
return function() {
return num;
};
}(i);
}
return rs;
}
這次不是直接把閉包塞進數組,而是先執行匿名函數再把結果塞進去。參數 num 按值接收 i 的副本,內部再返回一個訪問 num 的閉包,於是數組裡每個函數都持有自己那份 num。
var name = 'Jack';
var o = {
name : 'bingdian',
getName : function() {
return function() {
return this.name;
};
}
}
console.log(o.getName()()); // Jack
外層返回的普通函數在全局作用域下執行,this 指向 window,因此拿到的是 Jack。想拿到預期的值,用一個 self 把 this 存下來即可:
var name = 'Jack';
var o = {
name : 'bingdian',
getName : function() {
var self = this;
return function() {
return self.name;
};
}
}
console.log(o.getName()); // bingdian
function assignHandler() {
var el = document.getElementById('demo');
el.onclick = function() {
console.log(el.id);
}
}
assignHandler();
這裡創建了一個作為元素事件處理程序的閉包,同時形成循環引用:只要匿名函數還在,el 的引用數至少為 1,它所占的內存就永遠不會被回收。
function assignHandler() {
var el = document.getElementById('demo');
var id = el.id;
el.onclick = function() {
console.log(id);
}
el = null;
}
assignHandler();
把 el 置為 null 就能解除對 DOM 對象的引用,讓內存正常回收。
任何一對花括號中的語句集都構成一個塊,塊內定義的變量在塊外不可見,這就是塊級作用域。在 ES6 之前,我們常用立即執行函數來模擬它:
(function(){
// 塊級作用域
})();
一是保護函數內部的變量。outer 中的 i 只有 inner 能訪問,外部沒有其他途徑,安全性由此得到保障。
二是讓變量在內存中長期存活。i 一直留在內存裡,所以每次執行 rs() 都能在原有基礎上累加。
用得恰到好處,閉包是封裝與狀態保持的利器;用得隨意,它就是內存洩露與诡异 bug 的源頭。理解作用域鏈,才是用好閉包的前提。