閉包大概是 JavaScript 裡最常被提起、也最常被誤解的概念。它並不神秘,只是牽涉到作用域鏈與垃圾回收的運作細節。本文從最簡單的例子出發,逐步拆解閉包的成因、代價與常見陷阱。
閉包是指有權存取另一個函式作用域中變數的函式。 最常見的建立方式,是在一個函式內部定義另一個函式,並把內層函式回傳出去。
function a() {
var i = 0;
function b() {
alert(++i);
}
return b;
}
var c = a();
c();
這段程式有兩個關鍵特徵:函式 b 定義在 a 的內部,且 a 回傳了 b。執行 var c = a() 之後,c 實際上指向 b;再執行 c() 便會彈出 i 的值(第一次為 1)。
為什麼這叫閉包?因為 a 外部的變數 c 持有了 a 內部函式 b 的引用。當函式內部的函式被外部引用時,閉包就形成了。
最直白的說法是:閉包讓 JavaScript 的垃圾回收機制不敢回收外層函式佔用的資源,因為內層函式的執行還依賴外層的變數。
因此在上例中,a 執行完並回傳之後,i 依然存活在記憶體裡,每次呼叫 c() 都會讓 i 自增並印出新值。
反過來想:如果 a 回傳的不是函式 b,那 b 就只被 a 引用,a 也只被 b 引用,兩者互相引用卻不與外界連結,就會一起被回收。
要真正理解閉包,需要四個概念:執行環境(execution context)、活動物件(call object)、作用域(scope)與作用域鏈(scope chain)。以函式 a 從定義到執行的過程為例:
到這裡,a 把 b 的引用交給外部的 c;而 b 的作用域鏈裡含有對 a 活動物件的引用,所以 b 能讀到 a 中定義的所有變數。b 被 c 引用、b 又依賴 a,於是 a 不會被回收。
當 b 執行時也會經歷同樣流程,此時 b 的作用域鏈含三個物件:b 的活動物件、a 的活動物件、window。讀取變數時的搜尋順序是:先看自身的活動物件,找不到就往上找 a 的活動物件,再找不到就找 window,全都沒有則回傳 undefined。若 b 有 prototype,則在自身活動物件之後先查原型,再繼續往上。這就是 JavaScript 的變數查找機制。
絕大多數經典閉包案例都源自這兩點。此外,JavaScript 沒有區塊級作用域,因此我們常用「立即執行函式 + 閉包」來製造私有變數,避免污染全域。
在 JavaScript 中,不再被引用的物件會被 GC 回收;兩個物件互相引用但無第三方引用時,也會被回收。正常情況下,函式開始執行時建立執行環境與作用域鏈,執行結束後就釋放它們。
function test() {
var str = "hello world";
console.log(str);
}
test();

但閉包打破了这个常態:由於閉包函式需要存取外層函式的變數,外層函式執行結束後,它的作用域活動物件並不會被釋放,而是被閉包函式的作用域鏈繼續引用;直到閉包函式本身被銷毀,那個活動物件才會跟著消失。這正是閉包佔用記憶體的原因。
所以閉包有好處也有壞處,濫用會造成可觀的記憶體消耗。特別是在迴圈中大量建立閉包、或讓閉包長期持有大型物件時,更應該留意。
(function ($) {
var result = new Array(), i = 0;
for (; i < 10; i++) {
result[i] = function () {
return i;
};
}
$.RES1 = result;
})(jQuery);
$.RES1[0](); // 10,而不是期望的 0
這裡用匿名函式表達式開闢了一塊私有作用域,該匿名函式就是外層函式,它有一個參數 $,內部宣告了 result 與 i。迴圈替 result 的每個位置配置一個匿名函式,這些函式都存取了外層的 i,因此形成閉包。

問題在於:閉包存的是變數的引用,而不是當時的值。迴圈結束時 i 已經等於 10,所以無論呼叫哪一個函式,讀到的都是 10。
解法是再包一層,用立即執行函式把當下的 i 當作參數傳入,讓每個閉包各自綁定一個獨立的 num:
(function ($) {
var result = new Array(), i = 0;
for (; i < 10; i++) {
result[i] = function (num) {
return function () {
return num;
};
}(i);
}
$.RES2 = result;
})(jQuery);
console.log($.RES2[0]()); // 0

另一個更常見的同類錯誤是替元素綁事件:
<div id="divTest">
<span>0</span><span>1</span><span>2</span><span>3</span>
</div>
$(document).ready(function () {
var spans = $("#divTest span");
for (var i = 0; i < spans.length; i++) {
spans[i].onclick = function () {
alert(i); // 永遠是 4
};
}
});
同樣用 IIFE 修掉即可:
var spans2 = $("#divTest2 span");
$(document).ready(function () {
for (var i = 0; i < spans2.length; i++) {
(function (num) {
spans2[i].onclick = function () {
alert(num);
};
})(i);
}
});
內部函式就是定義在另一個函式中的函式:
function outerFn() {
function innerFn() { }
}
innerFn 被包在 outerFn 的作用域裡,因此在 outerFn 內部呼叫它是合法的,在外部呼叫則會出錯:
function outerFn() {
document.write("Outer function<br/>");
function innerFn() {
document.write("Inner function<br/>");
}
}
innerFn(); // Uncaught ReferenceError: innerFn is not defined
JavaScript 允許函式像任何資料一樣被傳遞,所以內部函式能夠「逃脫」定義它的外層函式。逃脫方式之一是把它指派給全域變數:
var globalVar;
function outerFn() {
document.write("Outer function<br/>");
function innerFn() {
document.write("Inner function<br/>");
}
globalVar = innerFn;
}
outerFn();
globalVar(); // 等同於呼叫 innerFn
innerFn(); // 仍然 ReferenceError:名字只存在於 outerFn 的作用域中
另一種方式是用回傳值帶出引用:
function outerFn() {
document.write("Outer function<br/>");
function innerFn() {
document.write("Inner function<br/>");
}
return innerFn;
}
var fnRef = outerFn();
fnRef();
這裡沒有修改任何全域變數,而是把 innerFn 的引用交給呼叫者保存。正因為即使離開了函式作用域,仍能透過引用呼叫內部函式,JavaScript 必須保留被引用的函式,並持續追蹤所有持有它的變數,直到最後一個變數消失,垃圾回收器才能釋放對應的記憶體。
內部函式也可以有自己的區域變數,每次呼叫都會重新建立:
function outerFn() {
function innerFn() {
var innerVar = 0;
innerVar++;
document.write("innerVar = " + innerVar + "<br/>");
}
return innerFn;
}
var fnRef = outerFn();
fnRef(); // innerVar = 1
fnRef(); // innerVar = 1
若改成讀寫全域變數,則會持續累加:
var globalVar = 0;
function outerFn() {
function innerFn() {
globalVar++;
document.write("globalVar = " + globalVar + "<br/>");
}
return innerFn;
}
var fnRef = outerFn();
fnRef(); // 1
fnRef(); // 2
而最關鍵的情況是讀寫父函式的區域變數:
function outerFn() {
var outerVar = 0;
function innerFn() {
outerVar++;
document.write("outerVar = " + outerVar + "<br/>");
}
return innerFn;
}
var fnRef = outerFn();
fnRef(); // outerVar = 1
fnRef(); // outerVar = 2
var fnRef2 = outerFn();
fnRef2(); // outerVar = 1
fnRef2(); // outerVar = 2
注意第二次呼叫 outerFn 並沒有延續之前的 2,而是從 1 重新開始。因為每次呼叫 outerFn 都會建立一個新的作用域,並在其中綁定一個新的 outerVar 實例,兩個計數器互不相關。
當內部函式在定義它的作用域之外被引用時,閉包就誕生了。 這些「既不是內部函式的區域變數、也不是它的參數」的變數被稱為自由變數,而外部函式的呼叫環境則稱為封閉閉包的環境。從本質上講,內部函式引用了外部函式的變數,等於授權那些變數延後使用,因此外部函式返回後,這些變數的記憶體不會被釋放。
當一個外層函式回傳多個內部函式時,它們會共享同一個封閉環境:
function outerFn() {
var outerVar = 0;
function innerFn1() {
outerVar++;
document.write("Inner function 1: outerVar = " + outerVar + "<br/>");
}
function innerFn2() {
outerVar += 2;
document.write("Inner function 2: outerVar = " + outerVar + "<br/>");
}
return { "fn1": innerFn1, "fn2": innerFn2 };
}
var fnRef = outerFn();
fnRef.fn1(); // outerVar = 1
fnRef.fn2(); // outerVar = 3
fnRef.fn1(); // outerVar = 4
innerFn1 與 innerFn2 引用的是同一個 outerVar,因此其中一個改動後,另一個看到的是新值。這個結構其實非常類似物件導向:自由變數相當於實例屬性,閉包相當於實例方法,而且因為這些變數無法從封裝它們的作用域外部直接存取,它們天然就是私有的。對 outerFn 的下一次呼叫則會產生全新的閉包實例與全新的封閉環境。
現在再來看開頭的例子就很清楚了:
for (var i = 0; i < spans.length; i++) {
spans[i].onclick = function () { alert(i); };
}
頁面載入後這段程式立刻執行,迴圈結束時 i 等於 4。每個 span 的 onclick 都是內部函式,閉包以引用方式持有 i,因此 i 的記憶體無法被回收,值一直保持 4。點擊 span 時,onclick 沿作用域鏈查到 i,得到 4,於是就 alert 出 4。
而第二種寫法多包了一層立即執行函式:函式宣告放進括號後就變成表達式,後面再加一組括號即為呼叫。i 被當成參數傳入並立即執行,num 於是保存了每次迴圈當下的值,各自的閉包也就彼此獨立。
讀到這裡,閉包的全貌應該已經清楚。若還想再深入,把「執行環境」與「作用域鏈」這兩個機制弄透,所有關於閉包的疑問都能自行推導出來。