DIV CSS 佈局教程網

深入理解 JavaScript(16):閉包 Closures
編輯:關於JavaScript     

前言

閉包大概是 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);
});

Funarg 問題

在基於堆疊的程式語言裡,函式的區域變數存在堆疊上:函式被呼叫時參數與區域變數壓入堆疊,函式回傳時一併移出。這種模型在把函式當值使用(例如作為回傳值)時會遇到嚴重限制,問題通常出現在自由變數上。

自由變數指的是函式中用到、但既不是參數也不是區域變數的變數:

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 的閉包實作

先強調一件事: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]]。也就是說,某個閉包修改了 [[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

閉包中的 return

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。

XML學習教程| jQuery入門知識| AJAX入門| Dreamweaver教程| Fireworks入門知識| SEO技巧| SEO優化集錦|
Copyright © DIV+CSS佈局教程網 All Rights Reserved