要理解閉包,必須先理解 JavaScript 特殊的作用域規則。本文從作用域談起,透過一系列由淺入深的範例,說明閉包如何實現私有資料、方法封裝與結果快取。
變數作用域只有兩種:全域與區域。JavaScript 的特殊之處在於:函數內部可以讀取全域變數,但函數外部無法讀取函數內部的區域變數。
還有一個關鍵注意點:函數內部宣告變數時一定要用 var(或 let / const),否則會變成全域變數。
閉包,就是一個受到保護的變數空間。
function foo() {
var num = Math.random();
return num;
}
var res = foo();
這段程式有個特性:每次呼叫 foo(),num 都會重新產生。函數執行時配置記憶體,執行完就回收,所以兩次呼叫拿到的值不同。
如果想取得「同一個」num,該怎麼辦?
function foo() {
var num = Math.random();
return function () {
return num;
};
}
var fn = foo(); // foo 只執行一次,num 唯一
var r1 = fn();
var r2 = fn();
console.log(r1 === r2); // true
原理:fn 是在 foo 內部定義的函數,執行時它能訪問到上一層作用域的 num。而 foo 執行完後,因為 fn 仍持有對 num 所在作用域的引用,該作用域不會被垃圾回收。這就是閉包,它起到了保護資料的作用。
理解閉包前,先確認一個事實——函數也是物件。
function Foo() {
var o = { num: 123 };
return o;
}
var obj = Foo();
console.log(obj.num); // 123
function Foo() {
var o = new Function('alert(123)');
return o;
}
var fn = Foo(); // 等同 var fn = new Function('alert(123)');
fn(); // 123
function func() {
var m = Math.random();
var n = Math.random();
return [
function () { return m; },
function () { return n; }
];
}
var fns = func();
console.log(fns[0]() === fns[0]()); // true,m 被保留下來
console.log(fns[1]() === fns[1]()); // true,n 被保留下來
陣列的優點是有序性,但在資料結構複雜時,索引的語義就消失了。改用物件會清楚得多:
function func() {
var m = Math.random();
var n = Math.random();
return {
get_M: function () { return m; },
get_N: function () { return n; }
};
}
var obj = func();
console.log(obj.get_M(), obj.get_N());
用一個函數提供兩個方法,對 num 進行賦值與讀取:
// 寫法一
function Foo() {
var obj = new Object(); // 也可寫成 var obj = {};
var num;
obj.get_num = function () { return num; };
obj.set_num = function (v) { num = v; };
return obj;
}
var o = Foo();
console.log(o.get_num()); // undefined
o.set_num(11);
console.log(o.get_num()); // 11
// 寫法二:更簡潔
function Foo() {
var num;
return {
get_num: function () { return num; },
set_num: function (v) { num = v; }
};
}
這就是「私有變數」的實現——外部無法直接存取 num,只能透過這兩個方法操作。
下面這個變體看似等價,其實不然:
function Foo() {
var num;
return {
_num: num, // 這裡只是「賦值」
set_num: function (v) { num = v; }
};
}
var o = Foo();
console.log(o._num); // undefined
o.set_num(11);
console.log(o._num); // undefined,取不到資料
原因:_num: num 是把 num 當時的值(undefined)複製一份給屬性 _num,兩者此後再無關聯。而 set_num 修改的是閉包裡的 num,_num 完全不動。這是初學者最容易誤解的地方——賦值與閉包引用是兩件不同的事。
var count = 0;
var fib = function (n) {
count++;
if (n < 0) throw new Error('不允許出現負數');
if (n === 0 || n === 1) return 1;
return fib(n - 1) + fib(n - 2); // 也可用 arguments.callee
};
console.log(fib(16));
console.log(count); // 3193
計算第 1、2、4、8、16、32 項的遞迴次數分別是 1、3、9、67、3193、7049155——指數級增長,效能災難。
var count = 0;
var fib = (function () {
var arr = []; // 快取表藏於閉包中
return function (n) {
count++;
if (n < 0) throw new Error('不允許出現負數');
var res = arr[n]; // 先查快取
if (res !== undefined) return res;
if (n === 0 || n === 1) {
res = 1;
} else {
res = fib(n - 1) + fib(n - 2);
}
arr[n] = res; // 寫入快取
return res;
};
})();
console.log(fib(100));
console.log(count); // 199
從 7049155 次降到 199 次,這就是快取的力量。而 arr 之所以能跨多次呼叫持續存在,正是因為它在閉包裡。
把快取表掛在函數自身屬性上,也能達到同樣效果:
var fib = function (n) {
var res = fib[n]; // 從函數自身的屬性取
if (res !== undefined) return res;
if (n === 0 || n === 1) {
res = 1;
} else {
res = arguments.callee(n - 1) + arguments.callee(n - 2);
}
fib[n] = res;
fib.len++;
return res;
};
fib.len = 0;
console.log(fib(100));
console.log(fib.len); // 101
這個寫法與閉包無關,但共享同一個思路:把計算結果存到某個「能跨呼叫存活」的地方。函數屬性與閉包變數,本質上都是達到這個目的的手段。
閉包並非免費:
// 錯誤示範
for (var i = 0; i < 3; i++) {
setTimeout(function () { console.log(i); }, 100);
}
// 輸出 3 3 3
// 解法一:IIFE
for (var i = 0; i < 3; i++) {
(function (j) {
setTimeout(function () { console.log(j); }, 100);
})(i);
}
// 解法二:let(推薦)
for (let i = 0; i < 3; i++) {
setTimeout(function () { console.log(i); }, 100);
}
閉包是 JavaScript 表達能力的核心來源之一——模塊化、私有變數、高階函數、防抖節流,背後都是它。理解它,才算真正跨進 JavaScript 的門檻。