閉包大概是 JavaScript 討論區裡被談到爛的話題,但多數說明都停在「函式內部回傳函式」的表層。這一章想換個角度,從理論層面拆解 ECMAScript 中的閉包究竟如何運作。
本系列文章彼此相關,建議先讀過第 14 章〈作用域鏈〉與第 12 章〈變數對象〉,理解會更透徹。
英文原文:https://dmitrysoshnikov.com/ecmascript/chapter-6-closures/
在函式式語言中(ECMAScript 也支援這種風格),函式本身就是資料:可以指派給變數、當成參數傳遞、作為回傳值。圍繞這個特性有幾個專有名詞。
值為函式的參數稱為函式式參數(Funarg):
function exampleFunc(funArg) {
funArg();
}
exampleFunc(function () {
alert('funArg');
});
接受 Funarg 的函式稱為高階函式(HOF),本例中的 exampleFunc 就是;以函式作為回傳值的,則稱為帶函式值的函式:
(function functionValued() {
return function () {
alert('returned function is called');
};
})()();
能以一般資料形式存在(當參數傳遞、接受 Funarg、作為回傳值)的函式,統稱第一類函式(first-class function)。在 ECMAScript 中,所有函式都是第一類物件。
接受自己作為參數的,叫自套用函式:
(function selfApplicative(funArg) {
if (funArg && funArg === selfApplicative) {
alert('self-applicative');
return;
}
selfApplicative(selfApplicative);
})();
回傳自己的,叫自複製函式:
(function selfReplicative() {
return selfReplicative;
})();
自複製有個有趣的用法:讓函式每次只接受集合中的一項,从而实现鏈式呼叫:
function registerModes(modes) {
modes.forEach(registerMode, modes);
}
registerModes(['roster', 'accounts', 'groups']);
// 自複製版本
function modes(mode) {
registerMode(mode);
return modes; // 回傳函式自身
}
// 鏈式呼叫
modes('roster')('accounts')('groups')
// 有點類似 jQueryObject.addClass("a").toggle().removeClass("b")
不過直接傳入整個集合,通常更有效率也更直觀。
Funarg 內部定義的變數,在 Funarg 被呼叫時就能存取,因為存儲上下文資料的變數對象在每次進入上下文時才建立:
function testFn(funArg) {
funArg(10); // 20
funArg(20); // 30
}
testFn(function (arg) {
var localVar = 10;
alert(arg + localVar);
});
在基於堆疊的程式語言裡,函式的區域變數存在堆疊上:函式被呼叫時參數與區域變數壓入堆疊,函式回傳時一併移出。這種模型在把函式當值使用(例如作為回傳值)時會遇到嚴重限制,問題通常出現在自由變數上。
自由變數指的是函式中用到、但既不是參數也不是區域變數的變數:
function testFn() {
var localVar = 10;
function innerFn(innerParam) {
alert(innerParam + localVar); // localVar 對 innerFn 而言是自由變數
}
return innerFn;
}
var someFn = testFn();
someFn(20); // 30
在堆疊模型下,testFn 執行結束後 localVar 就被移出堆疊,外部呼叫 innerFn 時自然會出錯;更根本的是,innerFn 本身也是 testFn 的區域變數,根本無法被回傳。
第二類問題出在動態作用域。當函式作為參數傳遞時,自由變數會沿著「當前活躍的動態鏈」查找,而不是函式建立時保存的靜態作用域鏈:
var z = 10;
function foo() {
alert(z);
}
foo(); // 10 —— 靜態與動態作用域結果相同
(function () {
var z = 20;
foo(); // 靜態作用域:10;動態作用域:20
})();
// 作為參數傳入時也一樣
(function (funArg) {
var z = 30;
funArg(); // 靜態作用域:10;動態作用域:30
})(foo);
即使 z 仍然存在,爭議依舊:不同呼叫現場下,z 該取哪一個上下文的版本?這兩類難題——函式作為回傳值、函式作為參數——合稱 Funarg 問題,而閉包正是為了解決它而生。
閉包是程式碼塊,加上建立該程式碼塊的上下文中的資料。
var x = 20;
function foo() {
alert(x); // 自由變數 x == 20
}
// fooClosure 為偽碼
fooClosure = {
call: foo, // 參照到函式
lexicalEnvironment: {x: 20} // 用於搜尋的上下文
};
在 ECMAScript 中,foo 已經具備一個內部屬性——建立它的上下文的作用域鏈。上例想强调的是:閉包建立的同時,上下文資料就被保存下來,之後呼叫時自由變數便能從保存的上下文中查到。
要把區域變數保存到上下文銷毀之後,堆疊實現顯然不適用,因此閉包的上層資料改以動態配置記憶體(堆)配合垃圾回收與引用計數來管理。這種方式效能低於堆疊,但各家引擎都能做優化:先分析函式是否真的用到自由變數、Funarg 或函式值,再決定資料放堆疊還是放堆。
先強調一件事:ECMAScript 只使用靜態(詞彙)作用域(Perl 那類語言則兩者皆可)。
var x = 10;
function foo() {
alert(x);
}
(function (funArg) {
var x = 20;
// x 在建立函式時就以詞彙方式靜態保存
funArg(); // 10,而不是 20
})(foo);
技術上,建立函式時的父級上下文資料保存在函式的內部屬性 [[Scope]] 中。若對 [[Scope]] 不熟悉,請先讀第 14 章;反過來說,完全理解 [[Scope]] 與作用域鏈之後,閉包也就沒有秘密了。
依函式建立的演算法,ECMAScript 中所有函式都是閉包,因為它們在建立時就保存了上層上下文的作用域鏈(不論後續是否被呼叫):
var x = 10;
function foo() {
alert(x);
}
// foo 是閉包
foo: <FunctionObject> = {
[[Call]]: <code block of foo>,
[[Scope]]: [
global: {
x: 10
}
],
... // 其他屬性
};
為了效能,若函式沒用到自由變數,實作上可以不保存副作用域鏈——不過 ECMA-262-3 對此並未做任何規定。
部分引擎允許直接存取閉包作用域。例如 Rhino 為函式的 [[Scope]] 提供了非標準的 __parent__ 屬性:
var global = this;
var x = 10;
var foo = (function () {
var y = 20;
return function () {
alert(y);
};
})();
foo(); // 20
alert(foo.__parent__.y); // 20
foo.__parent__.y = 30;
foo(); // 30
// 沿著作用域鏈一路往上
alert(foo.__parent__.__parent__ === global); // true
alert(foo.__parent__.__parent__.x); // 10
這點非常重要:在同一個父上下文中建立的閉包,共用同一個 [[Scope]]。也就是說,某個閉包修改了 [[Scope]] 中的變數,其他閉包讀到的也會跟著改變。
var firstClosure;
var secondClosure;
function foo() {
var x = 1;
firstClosure = function () { return ++x; };
secondClosure = function () { return --x; };
x = 2; // 影響兩個閉包共有的 AO["x"]
alert(firstClosure()); // 3
}
foo();
alert(firstClosure()); // 4
alert(secondClosure()); // 3
最常見的誤解就出在這裡:迴圈中建立函式,期望每個函式各自記住自己的計數值,結果卻全部拿到迴圈結束後的最終值。
var data = [];
for (var k = 0; k < 3; k++) {
data[k] = function () {
alert(k);
};
}
data[0](); // 3,而不是 0
data[1](); // 3,而不是 1
data[2](); // 3,而不是 2
// 因為三者共用同一個 Scope
activeContext.Scope = [
... // 其他變數對象
{data: [...], k: 3}
];
data[0].[[Scope]] === Scope;
data[1].[[Scope]] === Scope;
data[2].[[Scope]] === Scope;
解法是包一層 IIFE,把 k 當參數傳進去,為每個閉包建立獨立的變數對象:
var data = [];
for (var k = 0; k < 3; k++) {
data[k] = (function _helper(x) {
return function () {
alert(x);
};
})(k); // 傳入 k 的值
}
data[0](); // 0
data[1](); // 1
data[2](); // 2
發生了什麼事?_helper 每次被呼叫時都會建立一個新的變數對象,其中含參數 x,值就是當時的 k。於是回傳函式的 [[Scope]] 變成:
data[0].[[Scope]] === [
... // 其他變數對象
父級上下文 AO: {data: [...], k: 3},
_helper 上下文 AO: {x: 0}
];
data[1].[[Scope]] === [
... // 其他變數對象
父級上下文 AO: {data: [...], k: 3},
_helper 上下文 AO: {x: 1}
];
data[2].[[Scope]] === [
... // 其他變數對象
父級上下文 AO: {data: [...], k: 3},
_helper 上下文 AO: {x: 2}
];
要注意,回傳的函式若直接讀 k,拿到的仍然是 3。順帶澄清一個常見說法:很多文章認為「只有額外建立的函式才是閉包」,這是不精確的——那只是實務上最有效的寫法,理論上 ECMAScript 中所有函式都是閉包。
當然,解法不只一種,把 k 掛成函式屬性也行:
var data = [];
for (var k = 0; k < 3; k++) {
(data[k] = function () {
alert(arguments.callee.x);
}).x = k;
}
data[0](); // 0
data[1](); // 1
data[2](); // 2
ECMAScript 中,閉包裡的 return 只會把控制權交還給呼叫者,並不會跳出外層函式:
function getElement() {
[1, 2, 3].forEach(function (element) {
if (element % 2 == 0) {
// 這個 return 是給 forEach 的,不是給 getElement
alert('found: ' + element); // found: 2
return element;
}
});
return null;
}
若真的想達到「從外層函式跳出」的效果,只能繞道用例外:
var $break = {};
function getElement() {
try {
[1, 2, 3].forEach(function (element) {
if (element % 2 == 0) {
alert('found: ' + element); // found: 2
$break.data = element;
throw $break;
}
});
} catch (e) {
if (e == $break) {
return $break.data;
}
}
return null;
}
alert(getElement()); // 2
釐清兩個常見誤解:閉包不只是「從父上下文回傳的內部函式」,也不是「只有匿名函式才算閉包」。由於作用域鏈的關係,所有函式都是閉包,與函式類型無關(匿名函式、FE、NFE、FD 都算)。唯一的例外是以 Function 建構子建立的函式,因為它的 [[Scope]] 只包含全域物件。
因此給出兩個版本的正確定義:
理論上:所有函式都是閉包,因為它們在建立時就保存了上層上下文的資料。即使是存取全域變數,也等同於存取自由變數、使用最外層的作用域。
實務上:只有符合下列兩點的才算閉包——建立它的上下文已經銷毀、它仍然存在(例如內部函式從父函式回傳),並且程式碼中參照了自由變數。
閉包能寫出非常優雅的設計,讓 Funarg 上的計算方式可以被外部自訂。例如排序:
[1, 2, 3].sort(function (a, b) {
... // 排序條件
});
映射:
[1, 2, 3].map(function (element) {
return element * 2;
}); // [2, 4, 6]
搜尋條件:
someCollection.find(function (element) {
return element.someProperty == 'searchCondition';
});
套用函式:
[1, 2, 3].forEach(function (element) {
if (element % 2 != 0) {
alert(element);
}
}); // 1, 3
函式物件的 apply 與 call 也可視為應用函式:
(function () {
alert([].join.call(arguments, ';')); // 1;2;3
}).apply(this, [1, 2, 3]);
延遲呼叫:
var a = 10;
setTimeout(function () {
alert(a); // 10,一秒後
}, 1000);
回呼函式:
var x = 10;
xmlHttpRequestObject.onreadystatechange = function () {
// 資料就緒時才呼叫,此時 x 已存在
alert(x); // 10
};
封裝作用域以隱藏輔助物件:
var foo = {};
// 初始化
(function (object) {
var x = 10;
object.getX = function _getX() {
return x;
};
})(foo);
alert(foo.getX()); // 取得閉包中的 x —— 10
本章補充了更多 ECMAScript-262-3 的理論細節,我認為這些底層知識是理解閉包的關鍵。有問題歡迎在留言中討論。
其他參考:Javascript Closures(Richard Cornford)、Funarg problem、Closures。