本章要談的是 ECMAScript 中最常見的物件——函式。我們會逐一說明各種類型的函式如何影響上下文的變數對象、每個函式的作用域鏈包含什麼,並回答一個經常被提出的問題:下面兩種寫法有差別嗎?
var foo = function () {
...
};
function foo() {
...
}
以及,為什麼下面這種寫法要用括號把函式包起來?
(function () {
...
})();
相關背景請參考第 12 章〈變數對象〉與第 14 章〈作用域鏈〉。原文:https://dmitrysoshnikov.com/ecmascript/chapter-5-functions/
ECMAScript 有三種函式:函式聲明、函式表達式,以及透過建構子建立的函式。各有各的個性。
函式聲明具備三個特徵:
function exampleFunc() {
...
}
關鍵在於它只影響變數對象。這也解釋了另一個重要特性:在程式碼執行階段它已經可用,因為 FD 在進入上下文時就已存在於 VO 中。
foo(); // 可以在宣告之前呼叫
function foo() {
alert('foo');
}
另外,FD 只能出現在兩個位置:
// 1) 直接在全域上下文中
function globalFD() {
// 2) 或者在另一個函式的函式體內
function innerFD() {}
}
也就是說,不可能在表達式位置或程式碼塊中定義 FD。
函式表達式的特徵:
最單純的例子就是指派:
var foo = function () {
...
};
這裡把一個匿名函式表達式指派給 foo,之後透過 foo() 呼叫。FE 也可以有可選的名稱:
var foo = function _foo() {
...
};
外部用 foo() 存取,函式內部(例如遞迴)則可能用 _foo。若 FE 帶有名稱,就不容易與 FD 分辨;但只要記住「FE 永遠處於表達式位置」,判別就很直觀:
// 圓括號(分組運算子)內只能是表達式
(function foo() {});
// 陣列初始化式中只能是表達式
[function bar() {}];
// 逗號也只能操作表達式
1, function baz() {};
FE 只在執行階段建立、不存在於變數對象,因此宣告前後都取不到:
alert(foo); // undefined
(function foo() {});
alert(foo); // 依然 undefined
那我們為何需要 FE?因為它們能用在表達式中而不污染變數對象。最常見的場景是把函式當參數傳進另一個函式:
function foo(callback) {
callback();
}
foo(function bar() {
alert('foo.bar');
});
foo(function baz() {
alert('foo.baz');
});
或者建立封裝的閉包,把輔助資料藏在外部上下文之外:
var foo = {};
(function initialize() {
var x = 10;
foo.bar = function () {
alert(x);
};
})();
foo.bar(); // 10
alert(x); // undefined
foo.bar 透過 [[Scope]] 存取了 initialize 的內部變數 x,而外部無法直接存取 x。許多函式庫都用這招製造「私有」資料。這種模式下初始化 FE 的名稱通常直接省略:
(function () {
// 初始化作用域
})();
也能在執行階段透過條件運算式建立 FE,同樣不污染 VO:
var foo = 10;
var bar = (foo % 2 == 0
? function () { alert(0); }
: function () { alert(1); }
);
bar(); // 0
回到開頭的問題:為什麼立即呼叫必須用圓括號包住?答案是表達式語句的語法限制。依規範,表達式語句不能以 { 開頭(會與程式碼塊混淆),也不能以 function 關鍵字開頭(會與 FD 混淆)。因此下面兩種寫法都會出錯:
function () {
...
}();
// 即使有名稱也一樣
function foo() {
...
}();
第一例在全域層級會被當成 FD,而 FD 必須有名稱,於是丟出 SyntaxError。第二例中 foo 作為 FD 正常建立,但後面那組括號被解讀為分組運算子而非呼叫,於是報「缺少表達式」。
// "foo" 是 FD,進入上下文時建立
alert(foo); // function
function foo(x) {
alert(x);
}(1); // 這只是分組運算子,不是呼叫!
foo(10); // 這才是真正的呼叫,輸出 10
上面之所以沒問題,是因為它其實產生了兩個東西:一個 FD,一個含運算式 1 的分組運算。
// FD
function foo(x) {
alert(x);
}
// 含運算式 1 的分組運算子
(1);
// 另一個含 function 表達式的分組運算子
(function () {});
// 這個運算子裡包的是運算式 "foo"
("foo");
依規範,if (true) function foo() {alert(1)} 這種寫法是錯誤的(表達式語句不能以 function 開頭)。要告訴直譯器「我要建立 FE 並立刻呼叫」,最簡潔的方式就是用分組運算子括號包起來——括號裡永遠是表達式,直譯器不會誤判。函式在執行階段建立、立刻執行,若沒有其他參照便自動銷毀。
(function foo(x) {
alert(x);
})(1); // 這才是呼叫,不是分組運算子
反過來說,如果直譯器已經知道自己在處理 FE,括號就不是必要的。因為函式已處於表達式位置,解析器知道它會在執行階段被建立:
var foo = {
bar: function (x) {
return x % 2 != 0 ? 'yes' : 'no';
}(1)
};
alert(foo.bar); // 'yes'
此處 foo.bar 是一個字串而非函式——這個函式只用來依據參數初始化屬性,建立後立刻執行完畢。
所以「關於圓括號」的完整答案是:當函式不在表達式位置時,分組運算子的圓括號是必須的,用以手動把函式轉為 FE;若解析器本來就知道是 FE,就不需要括號。
除了括號,還有其他方式能把函式轉為 FE:
1, function () {
alert('anonymous function is called');
}();
!function () {
alert('ECMAScript');
}();
... // 其他手動轉換形式
不過圓括號仍是最簡潔的寫法。另外,分組運算子包住函式描述時,內外是否再包一層呼叫括號都可以,兩種寫法都是合法的 FE。
下面這段程式碼,依規範不該有任何一種 FD 能成立:
if (true) {
function foo() {
alert(0);
}
} else {
function foo() {
alert(1);
}
}
foo(); // 0 還是 1?不同環境實測結果不同
因為 FD 不能出現在程式碼塊中(這裡 if / else 都含程式碼塊),只能出現在程式層級或函式體內。程式碼塊只能包含語句,而唯一能放在塊中的函式位置是表達式語句——但它又不能以 { 或 function 開頭。
然而在標準的錯誤處理擴展中,這種語法被容許流傳,現存引擎都不會拋出異常,但各自的做法不同。
if-else 意味著動態選擇,邏輯上應該在執行階段建立 FE。但多數引擎在進入上下文時就建立 FD,並採用最後宣告的那個,於是 foo 顯示 1,else 分支永遠不會生效。
SpiderMonkey(與 TraceMonkey)的處理方式不同:一方面不把它當宣告(函式在執行階段依條件建立),另一方面由於沒有括號包圍、不符合 FD 形式,也不能被呼叫,因此也不是真正的 FE,而是存在變數對象中。我認為這種行為是正確的,它切出了一個函式中間類型——FE + FD。這些函式在恰當的時機依條件建立,又不像 FE 那樣無法從外部呼叫。SpiderMonkey 把這種語法擴展稱為函式語句(FS),MDC 中亦有提及。
當 FE 帶有名稱時,會出現一個關鍵特性。依定義 FE 不影響變數對象,所以外部無法用該名稱呼叫,但函式內部可以透過名稱遞迴呼叫自己:
(function foo(bar) {
if (bar) {
return;
}
foo(true); // "foo" 在內部可用
})();
foo(); // 外部:undefined
那麼 foo 存在哪裡?不在 foo 的活動對象中(內部並未定義 foo),也不在父變數對象中(否則外部就能取用)。答案是:當直譯器在執行階段遇到命名 FE 時,會先建立一個輔助的特殊物件並放到當前作用域鏈最前端,接著建立 FE(此時函式取得 [[Scope]]),然後把名稱作為唯一屬性掛到特殊物件上,值指向該 FE,最後再把特殊物件從父作用域鏈移除。
specialObject = {};
Scope = specialObject + Scope;
foo = new FunctionExpression;
foo.[[Scope]] = Scope;
specialObject.foo = foo; // {DontDelete}, {ReadOnly}
delete Scope[0]; // 從作用域鏈移除 specialObject
因此這個名稱在函式外部取不到(它不在父作用域鏈中),但特殊物件已存在函式的 [[Scope]] 裡,內部可用。
需要注意的是,部分實作(如 Rhino)把這個名稱存在 FE 的活動物件中;而 Microsoft 的實作完全打破了 FE 規則,把名稱保留在父變數對象上,導致函式在外部變得可存取。
SpiderMonkey 某些版本有一個與特殊物件相關的屬性,比較像是 bug。它牽涉到識別符解析機制:作用域鏈的解析是二維的,除了作用域鏈本身,還會考慮每個物件的原型鏈。若我們在 Object.prototype 上定義屬性並參照一個「不存在」的變數,就能看到這種機制:
Object.prototype.x = 10;
(function () {
alert(x); // 10
})();
在解析 x 時會走到全域物件,其上找不到 x;但 SpiderMonkey 的全域物件繼承自 Object.prototype,於是 x 被解析出來。
活動對象沒有原型,所以內部函式不會有這種行為。若定義區域變數 x 並在內部函式中參照它,變數會在父函式上下文中被解析:
Object.prototype.x = 10;
function foo() {
var x = 20;
// 函式聲明
function bar() {
alert(x); // 20,來自 foo 的 AO
}
bar();
// 匿名 FE 也一樣
(function () {
alert(x); // 20,同樣來自 foo 的 AO
})();
}
foo();
尽管如此,仍有實作給活動對象設了原型。在 Blackberry 的實作中,上例的 x 被解析為 10,因為既然在 Object.prototype 找到 foo 的值,就不會走到 foo 的活動對象:
AO(bar FD or anonymous FE) -> no ->
AO(bar FD or anonymous FE).[[Prototype]] -> yes - 10
同樣的情形也能在命名 FE 的特殊物件上看到。依規範這個特殊物件是普通物件(等同 new Object()),因此應從 Object.prototype 繼承屬性——這正是 SpiderMonkey(1.7 以上版本)的行為;其餘實作(含新的 TraceMonkey)不會為特殊物件設定原型:
function foo() {
var x = 10;
(function bar() {
alert(x); // 20,不是 10
// 查找路徑:
// AO(bar) - no -> __specialObject(bar) - no
// __specialObject(bar).[[Prototype]] - yes: 20
})();
}
Object.prototype.x = 20;
foo();
IE 內建的 JScript(直到 5.8 / IE8)有一堆與 NFE 相關的 bug,全部與 ECMA-262-3 矛盾,有些甚至會引發嚴重錯誤。
第一,它破壞了 FE 的主要規則:可選的 FE 名稱應存在特殊物件中、只能在函式自身內部存取,但 IE 直接把它存進父變數對象,並當成 FD 處理——建立於進入上下文階段,在原始碼定義之前就能存取。
// FE 在變數對象裡可見
testNFE();
(function testNFE() {
alert('testNFE');
});
// 定義結束後也依然可見,就像 FD
testNFE();
第二,把命名 FE 指派給變數時,JScript 會建立兩個不同的函式物件:
var foo = function bar() {
alert('foo');
};
alert(typeof bar); // "function"
alert(foo === bar); // false!
foo.x = 10;
alert(bar.x); // undefined
foo(); // "foo"
bar(); // "foo"
但如果把 NFE 與變數指派分開描述(例如用分組運算子),再指派給變數並檢查相等性,結果會是 true:
(function bar() {});
var foo = bar;
alert(foo === bar); // true
foo.x = 10;
alert(bar.x); // 10
這可以這樣解釋:進入上下文階段建立了 FD bar;執行階段又建立 FE bar,但沒有被儲存、沒有參照,於是被回收。最後只剩 FD bar 一個物件,其參照指派給 foo。
第三,透過 arguments.callee 間接參照函式時,會指向被激活的那個物件(因為存在兩個函式物件):
var foo = function bar() {
alert([
arguments.callee === foo,
arguments.callee === bar
]);
};
foo(); // [true, false]
bar(); // [false, true]
第四,JScript 像對待普通 FD 一樣對待 NFE,不服從條件運算式規則,會採用最後的定義:
var foo = function bar() {
alert(1);
};
if (false) {
foo = function bar() {
alert(2);
};
}
bar(); // 2
foo(); // 1
「邏輯上」的解釋是:進入上下文階段建立了最後遇到的 FD bar(含 alert(2));執行階段建立 FE bar 並指派給 foo,所以 foo() 輸出 1。邏輯很清楚,但既然實作本身已被破壞、程式碼又要依賴 JScript 的 bug,我給「邏輯上」加了引號。
第五,與全域物件屬性的建立有關。既然 NFE 被當成 FD 對待、存進變數對象,那麼指派給未限定的識別符(即沒有 var)時,若函式名稱與該識別符相同,屬性就不會被建立到全域物件上:
(function () {
// 不用 var 的話,就不是當前上下文的變數,
// 而是全域物件的一個屬性
foo = function foo() {};
})();
// 在匿名函式外部,foo 這個名字取不到
alert(typeof foo); // undefined
「邏輯」很清楚:進入上下文階段,FD foo 取得了匿名函式局部上下文的活動對象;執行階段名稱 foo 已存在於 AO 中,於是成為區域變數。後續的指派只是更新 AO 中既有的屬性 foo,而不是依 ECMA-262-3 在全域物件上建立新屬性。
這類函式的主要特點是:[[Scope]] 只包含全域物件。
var x = 10;
function foo() {
var x = 20;
var y = 30;
var bar = new Function('alert(x); alert(y);');
bar(); // 10,"y" is not defined
}
bar 的 [[Scope]] 不含 foo 上下文的 AO,所以 y 取不到,x 只能從全域物件取得。另外,Function 建構子有無 new 關鍵字是等價的。
這類函式的其他特點與 Equated Grammar Productions 及 Joined Objects 有關。作為優化建議(實作可以不用),規範提供了這些機制:若有一個 100 個元素的陣列,在迴圈中建立函式時,實作可以啟用 Joined Objects,讓所有元素共用同一個函式物件。
var a = [];
for (var k = 0; k < 100; k++) {
a[k] = function () {}; // 可能使用了 joined objects
}
但透過建構子建立的函式不會被合併:
var a = [];
for (var k = 0; k < 100; k++) {
a[k] = Function(''); // 一直是 100 個不同的函式
}
另一個與 Joined Objects 相關的例子:
function foo() {
function bar(z) {
return z * z;
}
return bar;
}
var x = foo();
var y = foo();
此處實作有權合併 x 與 y(使用同一個物件),因為兩個函式(包含它們的內部 [[Scope]])並無本質差異。因此透過建構子建立的函式總是需要更多記憶體資源。
下面的偽碼描述了函式建立的演算法(省略與 Joined Objects 相關的步驟),適用於所有函式類型:
F = new NativeObject();
// 屬性 [[Class]] 是 "Function"
F.[[Class]] = "Function"
// 函式物件的原型是 Function 的原型
F.[[Prototype]] = Function.prototype
// 參照到函式自身
// 呼叫運算式 F 時激活 [[Call]]
// 並建立新的執行上下文
F.[[Call]] = <reference to function>
// 在物件的普通建構子裡編譯
// [[Construct]] 由 new 關鍵字激活
// 並為新物件配置記憶體
// 然後呼叫 F.[[Call]] 初始化作為 this 傳入的新物件
F.[[Construct]] = internalConstructor
// 當前執行上下文的作用域鏈
// 例如建立 F 的上下文
F.[[Scope]] = activeContext.Scope
// 如果函式透過 new Function(...) 建立,那麼
F.[[Scope]] = globalContext.Scope
// 傳入參數的個數
F.length = countParameters
// F 物件建立的原型
__objectPrototype = new Object();
__objectPrototype.constructor = F // {DontEnum},迴圈中不可枚舉
F.prototype = __objectPrototype
return F
注意 F.[[Prototype]] 是「函式(建構子)」的原型,而 F.prototype 是「透過這個函式建立的物件」的原型。術語常被混用,某些文章把 F.prototype 稱為「建構子的原型」,其實並不正確。
這篇有點長,但把三種函式類型的差異梳理清楚之後,後續談物件與原型時會輕鬆很多。歡迎在留言中提問。
其他參考:ECMA-262-3 第 13 章 Function Definition、15.3 章 Function Objects。