閉包是 JavaScript 面試的必考題,但要真正吃透它,得先把作用域鏈與變數宣告規則弄明白。
function getPropNames(o, /*optional*/ a) {
a = a || [];
for (var p in o) {
a.push(p);
}
return a;
}
caller 回傳呼叫者函式:
function callfunc() {
if (callfunc.caller) {
alert(callfunc.caller.toString());
} else {
alert("沒有函式呼叫");
}
}
function handleCaller() { callfunc(); }
handleCaller(); // 顯示 handleCaller 的內容
callfunc(); // 沒有呼叫者,印出「沒有函式呼叫」
callee 讓匿名函式能自我遞迴:
alert((function (x) {
if (x <= 1) return 1;
return x * arguments.callee(x - 1);
}(5))); // 120,等於 5!
全域變數在函式內部可以存取;當區域變數與全域變數同名時,區域變數會遮蔽全域變數,且不會破壞全域的值。
var scope = "global scope";
function f() {
var scope = "local scope";
return scope;
}
alert(f()); // local scope
alert(scope); // global scope
區域變數一定要用 var 宣告。少了 var,在非嚴格模式下它會變成全域變數:
scope = "global scope";
function f() {
scope = "local scope"; // 少了 var!
return scope;
}
alert(f()); // local scope
alert(scope); // local scope,全域被污染了
在嚴格模式下這會直接丟出錯誤:
"use strict"; scope = "global scope"; // ReferenceError

所以,宣告變數時千萬不要省略 var(或 let/const),這能省掉一堆找不出原因的 bug。

"use strict"; scope; console.log(scope); // undefined var scope = "global scope"; console.log(scope); // global scope
為什麼在宣告之前就能讀取而不報錯?這要從作用域鏈說起。
JavaScript 是基於詞法作用域的語言。作用域鏈是一串物件組成的鏈表,記錄了該段程式碼「作用域中」的所有變數。當引擎需要查找 scope 時,會從鏈中第一個物件開始找,找到就回傳;找不到就往下一個物件找,直到鏈尾。若一路都找不到,才丟出錯誤。
所以上面那段程式碼的查找路徑是:scope → window(全域物件)。宣告已被提前,但賦值還沒發生,因此值是 undefined。
"use strict";
var scope = "global scope";
function f() {
console.log(scope);
var scope = "local scope";
console.log(scope);
}
f();
許多人會回答「先印 global scope,再印 local scope」,理由是函式一開始看到的是全域變數,後來才被區域變數覆蓋。這個推理在 C#、Java 中完全正確,但在 JavaScript 中是錯的。
關鍵這句話請記住:全域變數在整個程式中始終有定義;區域變數在宣告它的函式體以及其內嵌的函式內,始終是有定義的。因此函式裡的 var scope 從函式第一行起就存在,只是尚未賦值——兩個 console.log 分別印出 undefined 與 local scope。
另一個例子更反直覺:
var g = "global scope";
function f() {
for (var i = 0; i < 3; i++) {
for (var j = 0; j < 3; j++) { }
console.log(j);
}
console.log(i);
}
console.log(g);
f();

許多人以為 {} 區塊結束後 i、j 就會被回收,結果應該是 undefined。實際輸出卻是 3 和 3——因為 JavaScript(ES6 之前)只有函式作用域,沒有區塊作用域,var 宣告的變數整個函式內都有效。

順帶一提,函式的參數也屬於區域變數的範疇,這一點同樣重要。
1. 作用域鏈始終由全域物件收尾。
2. 在不包含嵌套的函式體內,作用域鏈上有兩個物件:第一個存放函式參數與區域變數,第二個是全域物件。
3. 在嵌套的函式體內,作用域鏈至少包含三個物件。
定義函式時會保存一份作用域鏈;呼叫函式時,引擎會建立新物件存放區域變數,把它接到保存的鏈上,形成更長的作用域鏈。對嵌套函式而言,每次呼叫外部函式都會重新定義內部函式,兩者的程式碼相同,但關聯的作用域各不相同。
先看一個依作用域鏈追值的例子:
var nameg = "global";
var g = function f() {
console.log(name);
var name = "f-scope";
function demo0() { console.log("demo0=" + name); }
function demo1() { var name = "demo1-scope"; console.log("demo1=" + name); }
function demo2() { console.log("demo2=" + nameg); }
demo0(); demo1(); demo2();
};
g();
依鏈查找:demo0 在自己身上找不到 name,往 f 找到,印出 f 作用域的值;demo1 找到自己區域的 name;demo2 找 nameg,自身沒有、f 沒有、往 window 找到。
接著看閉包最典型的樣貌——計數器:
function f() {
var count = 0;
return {
counter: function () { return count++; },
reset: function () { return count = 0; }
};
}
var d = f();
var c = f();
console.log("d 第一次呼叫:" + d.counter()); // 0
console.log("c 第一次呼叫:" + c.counter()); // 0,互不影響
console.log("d 重置:" + d.reset()); // 0
console.log("c 第二次呼叫:" + c.counter()); // 1
d 與 c 各自持有獨立的作用域鏈,所以互不干擾;而 c 第二次呼叫時 count 仍記得上次的值,因為 c 這個物件並未被回收,它引用的 count 也就活了下來。這就是閉包的本質:函式連同它被定義時所處的作用域一起被保留。
function btnInit() {
for (var i = 0; i < 4; i++) {
var btn = document.getElementById("btn" + i);
btn.addEventListener("click", function () {
alert("btn" + i);
});
}
}
window.onload = btnInit;
四顆按鈕,點下去卻全部顯示 btn4。原因用作用域鏈一分析就清楚:點擊時才執行匿名函式 → 自身找不到 i → 往 btnInit 找,此時迴圈早已結束,i 停在最終值。
解法是用一層立即呼叫的函式把 i 的當前值固定下來:
function btnInit() {
for (var i = 0; i < 4; i++) {
(function (data_i) {
var btn = document.getElementById("btn" + data_i);
btn.addEventListener("click", function () {
alert("btn" + data_i);
});
}(i));
}
}
每輪迴圈都建立一個新的作用域,data_i 各自綁定當下的 i,互不影響,結果就正確了。若使用 ES6,直接把迴圈變數改成 let 也能達到同樣效果,因為 let 天生具備區塊作用域。