閉包是 JavaScript 面試的必考題,也是從「會寫」走向「寫得好」的分水嶺。要理解它,得先從作用域說起。
JavaScript 的作用域基本上只有兩種:全域與區域。這個語言的特殊之處在於,函式內部可以直接讀取全域變數:
var n = 999;
function f1() {
alert(n);
}
f1(); // 999
反之,函式外部無法讀取函式內部的區域變數:
function f1() {
var n = 999;
}
alert(n); // 錯誤
這裡有個容易踩的坑:函式內部宣告變數一定要加 var(或 let / const)。漏掉的話,你其實是在建立一個全域變數:
function f1() {
n = 999; // 沒有 var,n 變成全域
}
f1();
alert(n); // 999
正常情況下辦不到,得繞個路——在函式內部再定義一個函式。
function f1() {
var n = 999;
function f2() {
alert(n); // 999
}
}
f2 被包在 f1 裡面,因此 f1 的所有區域變數對 f2 都是可見的;反過來則不行,f2 的區域變數對 f1 不可見。這就是 JavaScript 特有的鏈式作用域(chain scope)結構:子物件會一層層往上找父物件的變數,父的可見於子,子的不可見於父。
既然 f2 能讀到 f1 的區域變數,那把 f2 當成回傳值丟出去,不就等於在 f1 外部開了一扇窗?
function f1() {
var n = 999;
function f2() {
alert(n);
}
return f2;
}
var result = f1();
result(); // 999
上面那段程式碼裡的 f2,就是一個閉包。教科書上的定義往往抽象難懂,比較好懂的解釋是:閉包就是能讀取其他函式內部變數的函式。由於只有函式內部的子函式才讀得到區域變數,所以也可以簡單理解成「定義在函式內部的函式」。
本質上,閉包是連接函式內部與外部的一座橋。
兩個主要用途:一是讀取函式內部的變數;二是讓那些變數的值持續留在記憶體中。
function f1() {
var n = 999;
nAdd = function () { n += 1; };
function f2() {
alert(n);
}
return f2;
}
var result = f1();
result(); // 999
nAdd();
result(); // 1000
result 跑了兩次,值從 999 變成 1000,證明 f1 的區域變數 n 並沒有在 f1 執行完畢後被清除。原因在於:f1 是 f2 的父函式,而 f2 被一個全域變數引用著,因此 f2 一直在記憶體裡;f2 的存在又依賴 f1,於是 f1 也留了下來,不會被垃圾回收機制回收。
這裡還有兩個細節值得注意。第一,nAdd = function(){...} 前面沒有 var,所以 nAdd 是全域變數。第二,它的值是一個匿名函式,而這個匿名函式本身也是閉包,因此 nAdd 形同一個 setter,可以在外部操作函式內部的區域變數。
記憶體:閉包會讓函式中的變數持續佔用記憶體,用量不小,因此不能濫用,否則可能造成效能問題,在舊版 IE 中甚至導致記憶體洩漏。解法是在離開函式前,把不再需要的區域變數清掉。
可變性:閉包會在父函式外部改變父函式內部變數的值。如果你把父函式當物件用、把閉包當公開方法、把內部變數當私有屬性,那就要小心,別讓外部輕易改動內部狀態。
如果你能說出下面程式碼的結果,大致就掌握閉包的運作機制了:
var name = "The Window";
var object = {
name: "My Object",
getNameFunc: function () {
return function () {
return this.name;
};
}
};
alert(object.getNameFunc()()); // "The Window"
答案是 "The Window" 而非 "My Object"。因為那個匿名函式是以「普通函式呼叫」的方式被呼叫的,此時 this 指向全域物件,而不是 object。若想拿到 "My Object",得把 this 用閉包或 bind 固定下來。
先看一段錯誤示範:
function outerFun() {
var a = 0;
function innerFun() {
a++;
alert(a);
}
}
innerFun(); // 錯誤:innerFun 的作用域在 outerFun 內部,外部呼叫不到
改成閉包寫法即可:
function outerFun() {
var a = 0;
function innerFun() {
a++;
alert(a);
}
return innerFun; // 關鍵在這裡
}
var obj = outerFun();
obj(); // 1
obj(); // 2
var obj2 = outerFun();
obj2(); // 1
obj2(); // 2
兩個 obj 各自獨立,因為每次呼叫 outerFun() 都會產生全新的作用域與全新的 a。
閉包的定義:當內部函式在它被定義的作用域之外被引用時,就建立了該內部函式的閉包。若內部函式參考了外部函式的變數,即使外部函式已經執行完畢,那些變數在記憶體中也不會被釋放,因為閉包需要它們。
再看一段對比:
function outerFun() {
var a = 0; // 有 var,a 屬於 outerFun 內部
alert(a);
}
var a = 4;
outerFun();
alert(a); // 0, 4
function outerFun() {
a = 0; // 沒有 var
alert(a);
}
var a = 4;
outerFun();
alert(a); // 0, 0
為什麼第二個例子會變成 0, 0?作用域鏈描述的是「決定變數值的查找路徑」。執行 a = 0 時因為沒有 var, assignment 會沿著作用域鏈往外找到全域的 var a = 4 並改寫它。
官方對閉包的解釋是:一個擁有許多變數並綁定了這些變數的環境的表達式(通常是一個函式)。翻成白話:JavaScript 中所有的 function 都是閉包,而嵌套 function 產生的閉包更強大,這也是我們平常所說的「閉包」。
function a() {
var i = 0;
function b() { alert(++i); }
return b;
}
var c = a();
c(); // 1
這段程式有兩個特點:b 嵌套在 a 內部;a 回傳 b。當 a 內部的函式 b 被 a 外部的變數引用時,閉包就誕生了。

也就是說,閉包讓 JavaScript 的垃圾回收機制不會在 a 執行完畢後立刻回收 a 所占用的資源,因為 a 的內部函式 b 仍依賴 a 中的變數。反過來說,如果 a 回傳的不是 b,那麼 a 與 b 互相引用卻不被外界引用,就會一起被回收。
以函式 a 從定義到執行的過程為例:
此時 a 把 b 的引用回傳給 c。由於 b 的作用域鏈包含對 a 活動物件的引用,b 就能存取 a 中定義的所有變數與函式;b 被 c 引用,b 又依賴 a,所以 a 在回傳後不會被回收。
當 b 執行時也是同樣流程。此時 b 的作用域鏈有三個物件:b 的活動物件、a 的活動物件、window。

因此,在 b 中查詢一個變數時的順序是:先找自己的活動物件,找不到就往 a 的活動物件找,再往上一層,直到找到為止。若 b 有 prototype 原型物件,會在查完自身活動物件後先查原型,再繼續往上。整條鏈都找不到,就回傳 undefined。
這一點很關鍵,用一段程式碼驗證:
function f(x) {
var g = function () { return x; };
return g;
}
var h = f(1);
alert(h());
如果作用域是在「執行時」才決定,那 h 的作用域鏈會是「h 的活動物件 → alert 的活動物件 → window」,輸出 undefined。如果是在「定義時」決定,則鏈是「h 的活動物件 → f 的活動物件 → window」,輸出 1。實際結果是 1,證明作用域在函式定義時就已確定。
保護變數安全:a 中的 i 只有 b 能存取,外部沒有其他途徑,因此 i 受到了保護。
在記憶體中維持變數:每次呼叫 c() 都會讓 i 自增,狀態被保留下來。
實作私有屬性與私有方法:在 Constructor 外部無法存取用閉包包起來的成員。
function Constructor(...) {
var that = this;
var membername = value;
function membername(...) { ... }
}
這三點是最基礎的應用,多數經典設計模式(模組模式、IIFE、部分物件導向封裝)都由此延伸而來。
在 JavaScript 中,當一個物件不再被任何變數引用,它就會被 GC 回收;兩個物件互相引用但沒有第三方引用,也會被回收。a 被 b 引用、b 又被外部的 c 引用,這正是 a 執行完畢後仍不被回收的原因。
理解閉包,是邁向進階 JavaScript 開發者的必經之路。掌握它的解釋與運作機制,你才能寫出更安全、更優雅的程式碼。