如果對作用域鏈和「函數是一等對象」這兩個概念理解到位,閉包幾乎是水到渠成的事。很多時候我們在寫 DOM 事件處理時已經不自覺地在用閉包了——只是叫不出名字,於是遇到問題時也容易一頭霧水。
JavaScript 裡函數是對象,對象是屬性的集合,屬性的值又可以是一個對象,因此在函數內部定義函數理所當然。如果在函數 func 內部聲明了函數 inner,並在 func 外部通過某種途徑調用了 inner,這個過程就產生了一個閉包:inner 保持著對 func 作用域的引用,即使 func 早已返回。
var outter = [];
function clouseTest() {
var array = ["one", "two", "three", "four"];
for (var i = 0; i < array.length; i++) {
var x = {};
x.no = i;
x.text = array[i];
x.invoke = function () { print(i); };
outter.push(x);
}
}
clouseTest();
print(outter[0].invoke());
print(outter[1].invoke());
print(outter[2].invoke());
print(outter[3].invoke());
初學者多半會猜 0 1 2 3。實際輸出是:
4 4 4 4
原因在於賦值那一刻什麼都沒發生。循環裡的 x.invoke = function(){ print(i); } 只是創建了一個函數對象,並沒有執行它,也沒有把當下的 i 定格下來。函數體裡的 i 是一個對外層變量的引用。等循環結束、i 自增到 4 導致條件不成立時,外層函數返回;此後無論調用哪個 invoke,讀到的都是同一個 i,也就是 4。
這裡要牢記一條:閉包引用的不是變量創建時的值,而是外層函數中該變量最後的值。
function clouseTest2() {
var array = ["one", "two", "three", "four"];
for (var i = 0; i < array.length; i++) {
var x = {};
x.no = i;
x.text = array[i];
x.invoke = (function (no) {
return function () { print(no); };
})(i); // 聲明後立即執行,把當前的 i 傳進新的作用域
outter.push(x);
}
}
clouseTest2();
外層那個匿名函數返回一個函數,並被立即調用。每次迭代相當於分別執行:
x.invoke = function () { print(0); };
x.invoke = function () { print(1); };
x.invoke = function () { print(2); };
x.invoke = function () { print(3); };
因為 no 是每次調用時新建的參數,各次迭代互不干擾,結果正確。(用 let i 替代 var i 也能直接解決,因為 let 在每次循環迭代中創建新的綁定。)
設想一個耗時的函數,每次調用都要花很久。我們希望把結果存起來,下次先查緩存。閉包正好能做到——因為它不會釋放外層引用,內部狀態得以在多次調用之間保留。
var CachedSearchBox = (function () {
var cache = {},
count = [];
return {
attachSearchBox: function (dsid) {
if (dsid in cache) { // 命中緩存
return cache[dsid];
}
var fsb = document.getElementById(dsid);
cache[dsid] = fsb; // 更新緩存
count.push(dsid);
if (count.length > 100) { // 控制緩存上限
delete cache[count.shift()];
}
return fsb;
},
clearSearchBox: function (dsid) {
if (dsid in cache) {
cache[dsid].clearSelection();
}
}
};
})();
var obj1 = CachedSearchBox.attachSearchBox("input1");
var obj2 = CachedSearchBox.attachSearchBox("input1"); // 直接命中緩存
var person = (function () {
// 下面的 name 屬於函數作用域,外部無法直接訪問
var name = "default";
return {
getName: function () { return name; },
setName: function (newName) { name = newName; }
};
})();
print(person.name); // undefined,直接訪問不到
print(person.getName()); // default
person.setName("jack");
print(person.getName()); // jack
輸出依次是 undefined、default、jack。傳統的面向對象語言通過 class 模板讓不同實例各自持有獨立狀態;JavaScript 沒有 class(ES6 之前),但可以借助閉包模擬:
function Person() {
var name = "default";
return {
getName: function () { return name; },
setName: function (newName) { name = newName; }
};
}
var john = Person();
print(john.getName()); // default
john.setName("john");
print(john.getName()); // john
var jack = Person();
print(jack.getName()); // default —— 兩次調用各有獨立閉包
jack.setName("jack");
print(jack.getName()); // jack
每次調用 Person() 都創建新的作用域,因此 john 和 jack 的 name 互不干擾。這就是「用閉包模擬私有成員」的經典範式。
不同 JS 引擎的實現各有缺陷,使用閉包確實可能導致內存洩漏。引擎普遍採用引用計數進行垃圾回收,計數為零則回收,這個過程本來是自動的。但閉包讓局部的變量可能在未來某個時刻被使用,因此回收器不會處理被外部引用的局部變量;一旦再出現循環引用(A 引用 B、B 引用 C、C 又引用回 A),計數永遠不為零,內存就洩了。洩漏會拖慢浏覽器響應、影響體驗,嚴重時導致無響應。
實戰中降低風險的做法:不需要時主動把引用置為 null;避免在閉包裡無必要地捕獲龐大對象;頁面卸載前解綁事件。
$(function () {
var con = $("div#panel");
this.id = "content";
con.click(function () {
alert(this.id); // 彈出的是 panel,不是 content
});
});
很多人會按閉包的概念推斷:外層設了 this.id = "content",click 回調形成閉包,引用到的應該是 content。實際彈出的是 panel。
關鍵在於:閉包能引用局部變量,但 this 的解析規則獨立於作用域鏈。當閉包作為事件處理器被調用時,this 指向觸發事件的對象(這裡是 #panel 這個 jQuery 對象)。而外層 $(function(){...}) 中的 this 指向的是另一個對象(在 jQuery 的就緒回調裡通常指 document)。兩個 this 從來不是同一個。
要在事件處理函數裡訪問外層那個 this,標準做法是先用一個局部變量把它存下來:
$(function () {
var con = $("div#panel");
this.id = "content";
var self = this; // 保存外層 this 的引用
con.click(function () {
alert(self.id); // content
});
});
這個 var self = this 的技巧在實戰中隨處可見。ES6 之後,箭頭函數因為不綁定自己的 this、直接沿用外層詞法作用域的 this,從根本上消除了這類問題,新項目可以優先考慮。
閉包不是什麼高深特性,它就是「函數 + 它所在的作用域」這麼一個組合。理解它的關鍵是記住兩條:變量的值取決於執行時刻而非創建時刻;this 由調用方式決定而不受閉包影響。剩下的實用價值——緩存、封裝、模擬私有——都是這兩條的自然延伸。