在 JavaScript 的世界裡,有名函數表達式(Named Function Expression)是一個既實用又充滿陷阱的概念。由於網路上相關的優質文章並不多,導致人們對它產生了許多誤解。本文將從理論與實踐兩個層面,全面剖析這一 JavaScript 結構的優缺點與跨瀏覽器的種種問題。
簡而言之,有名函數表達式主要有一個用途——在除錯器與效能分析器中提供具描述性的函數名稱。當然,它也可以用於遞迴呼叫,但正如我們稍後會看到的,這在當今往往並不實用。如果你並不在意除錯體驗,那麼完全可以不去理會它;否則,就繼續往下讀,看看你可能需要面對的跨瀏覽器問題,以及如何妥善地繞過它們。
在 ECMAScript 中,建立函數物件最常見的方式有兩種:函數表達式(Function Expression)與函數聲明(Function Declaration)。兩者的差異相當令人困惑。ECMA 規範中唯一明確的是:函數聲明必須帶有一個標識符(也就是函數名),而函數表達式則可以省略它。
FunctionDeclaration :
function Identifier ( FormalParameterList? ){ FunctionBody }
FunctionExpression :
function Identifier? ( FormalParameterList? ){ FunctionBody }
我們可以看到,當標識符被省略時,這個結構只能是一個表達式。但如果標識符出現了,該如何分辨它究竟是函數聲明還是函數表達式呢?畢竟兩者看起來一模一樣。答案是——ECMAScript 會依據上下文來區分:如果 function foo(){} 是某個賦值表達式的一部分,它就被視為函數表達式;反之,若它被包在函數主體中,或位於程式的最頂層,則會被解析為函數聲明。
function foo(){}; // 聲明,因為它是 Program 的一部分
var bar = function foo(){}; // 表達式,因為它是 AssignmentExpression 的一部分
new function bar(){}; // 表達式,因為它是 NewExpression 的一部分
(function(){
function bar(){}; // 聲明,因為它是 FunctionBody 的一部分
})();
聲明與表達式在行為上存在著細微的差異。首先,函數聲明會在任何其他表達式之前被解析與求值。即使聲明被放在程式碼的最後,它也會在包含它的作用域內優先於所有其他表達式被求值。下面的例子說明了這一點——即便 fn 函數是在 alert 之後才聲明的,但執行 alert 時它早已存在:
alert(fn());
function fn() {
return 'Hello world!';
}
函數聲明的另一個重要特徵是:在條件語句中聲明它們並不符合標準,且在不同環境(瀏覽器)中的行為各不相同。因此,你永遠不應依賴條件式的函數聲明,而應改用函數表達式。
// 千萬不要這樣做!
// 有些瀏覽器會把 foo 聲明為返回 'first' 的版本,
// 有些則是返回 'second' 的版本
if (true) {
function foo() { return 'first'; }
}
else {
function foo() { return 'second'; }
}
foo();
// 正確做法是使用函數表達式:
var foo;
if (true) {
foo = function() { return 'first'; }
}
else {
foo = function() { return 'second'; }
}
foo();
函數表達式其實非常常見。在 Web 開發中,一個典型的模式是根據某種特性檢測來「分叉」函數定義,以達到最佳效能。由於這種分叉通常發生在同一個作用域內,因此幾乎總是需要使用函數表達式:
var contains = (function() {
var docEl = document.documentElement;
if (typeof docEl.compareDocumentPosition != 'undefined') {
return function(el, b) {
return (el.compareDocumentPosition(b) & 16) !== 0;
}
}
else if (typeof docEl.contains != 'undefined') {
return function(el, b) {
return el !== b && el.contains(b);
}
}
return function(el, b) {
if (el === b) return false;
while (el != b && (b = b.parentNode) != null);
return el === b;
}
})();
很顯然,當一個函數表達式帶有名稱(技術上來說就是一個標識符)時,它就叫做有名函數表達式。你在第一個例子 var bar = function foo(){}; 中看到的正是如此。一個必須牢記的重要細節是:這個名稱只在新定義的函數作用域內可用,規範要求這個標識符不應對外層作用域可見。
var f = function foo(){
return typeof foo; // "foo" 在內部作用域可訪問
};
// 'foo' 在外部永遠不可見
typeof foo; // "undefined"
f(); // "function"
那麼,有名函數表達式究竟有何特別之處?為什麼我們要給它們命名呢?答案是:有命名的函數能帶來更好的除錯體驗。當你除錯一個應用時,一個帶有描述性名稱的呼叫堆疊會讓一切變得清晰明瞭得多。
當一個函數擁有對應的標識符時,除錯器在檢視呼叫堆疊時會將其顯示為函數名。有些除錯器(例如 Firebug)甚至能顯示匿名函數的名稱,讓它們與被賦值的變數名保持一致。不幸的是,這些除錯器通常依賴簡單的解析規則,而這種提取方式往往相當脆弱,經常產生錯誤的結果。
讓我們看一個簡單的例子:
function foo(){ return bar(); }
function bar(){ return baz(); }
function baz(){ debugger; }
foo();
// 呼叫堆疊看起來非常具有描述性:
// baz
// bar
// foo
// expr_test.html()
Firebug 表現優異的一點是,即使使用匿名表達式,它也能設法解析出函數的名稱:
function foo(){ return bar(); }
var bar = function(){ return baz(); }
function baz(){ debugger; }
foo();
// 呼叫堆疊:
// baz
// bar()
// foo
// expr_test.html()
然而,一旦函數表達式變得更複雜(在真實場景中幾乎總是如此),除錯器的種種努力便付諸流水,取而代之的是一個突兀的問號:
function foo(){ return bar(); }
var bar = (function(){
if (window.addEventListener) {
return function(){ return baz(); }
}
else if (window.attachEvent) {
return function() { return baz(); }
}
})();
function baz(){ debugger; }
foo();
// 呼叫堆疊:
// baz
// (?)()
// foo
// expr_test.html()
另一個令人困惑的情況是,當同一個函數被賦值給多個變數時:
function foo(){ return baz(); }
var bar = function(){ debugger; };
var baz = bar;
bar = function() { alert('spoofed'); }
foo();
// 呼叫堆疊顯示 foo 呼叫了 bar,
// 但實際上發生的並非如此
// bar()
// foo
// expr_test.html()
歸根結底,有名函數表達式是獲得真正可靠堆疊檢視的唯一途徑。讓我們用它來重寫前面的例子,注意兩個從自執行包裹中返回的函數都被命名為 bar:
function foo(){ return bar(); }
var bar = (function(){
if (window.addEventListener) {
return function bar(){ return baz(); }
}
else if (window.attachEvent) {
return function bar() { return baz(); }
}
})();
function baz(){ debugger; }
foo();
// 再一次,我們獲得了具描述性的呼叫堆疊!
// baz
// bar
// foo
// expr_test.html()
在我們歡呼雀躍之前,還是先來看看 IE 的 ECMAScript 實作——JScript 的表現。遺憾的是,JScript 對有名函數表達式的處理簡直是一團糟,這也正是它被許多人「勸退」的根源。
var f = function g(){};
typeof g; // "function"
前面提到,有名函數表達式的標識符不應在外層作用域中可見。但 JScript 並不買帳——上面的 g 竟然解析為一個函數物件。這是最常見的差異,它會在無意間污染外層作用域(甚至可能是全域作用域),埋下難以追蹤的 bug 伏筆。
typeof g; // "function"
var f = function g(){};
JScript 實際上把有名函數表達式當作函數聲明來對待,會在「真正的聲明」發生前就先行解析 g。
var f = function g(){};
f === g; // false
f.expando = 'foo';
g.expando; // undefined
這裡事情變得棘手了。我們必須面對兩個截然不同的物件——擴充其中一個並不會影響另一個。如果你打算在 f 的屬性中快取一些資料,卻誤以為 g 指向同一物件而去存取,就會引發各種難題。
var f = function g() { return 1; };
if (false) {
f = function g(){ return 2; }
};
g(); // 2
由於 JScript 中的聲明與條件塊無關,g 會作為來自「死」if 分支的函數 function g(){ return 2 } 被聲明。若你在 f 內部不小心呼叫了 g,最終將呼叫到一個完全不相干的 g 函數物件。
至於 arguments.callee 引用的是 f 還是 g 呢?
var f = function g(){
return [
arguments.callee == f,
arguments.callee == g
];
};
f(); // [true, false]
可見 arguments.callee 引用的是與 f 相同的物件,這是個好消息。綜合 JScript 的種種缺陷,我們應該:意識到標識符的洩漏、永遠不要引用作為函數名的標識符(一律透過 f 或 arguments.callee 引用函數),並且在最後清理掉那個被錯誤創建的附加函數。
熟悉 JScript 的這些差異後,我們能預見使用這些缺陷結構時的潛在記憶體問題:
var f = (function(){
if (true) {
return function g(){};
}
return function g(){};
})();
問題在於,那個多餘的 g 函數被「困」在返回函數的閉包裡,除非我們顯式地中斷對 g 函數的引用,否則它會持續佔用記憶體。
var f = (function(){
var f, g;
if (true) {
f = function g(){};
}
else {
f = function g(){};
}
// 給 g 賦值 null,使其不再引用多餘的函數
g = null;
return f;
})();
注意我們顯式聲明了 g,這樣 g = null 就不會在符合規範的客戶端中創建一個全域變數。透過將 g 設為 null,我們允許垃圾回收器清除那個被隱式創建的函數物件。
測試非常簡單:透過有名函數表達式建立 10000 個函數並存入陣列,等待約一分鐘後檢視記憶體佔用,再將引用設為 null 重複流程。在 Windows XP SP2 上透過 Process Explorer 得到的結果如下:
IE6:
without `null`: 7.6K -> 20.3K
with `null`: 7.6K -> 18K
IE7:
without `null`: 14K -> 29.7K
with `null`: 14K -> 27K
結果證實,顯式地將多餘引用設為 null 確實能釋放記憶體,但差異相對有限——對 10000 個函數物件而言,大約有 3MB 的差距。在設計大規模應用,或運行於記憶體受限設備(如行動裝置)上的應用時,這一點值得留意;而對於小型腳本,差異則幾乎可以忽略。
較少為人知的是,舊版 Safari(2.x 系列)也存在有名函數表達式的 bug。網路上有些說法稱 Safari 2.x 完全不支援它,這並不準確——Safari 確實支援,只是實作中存在缺陷。
當在某些上下文中遇到函數表達式時,Safari 2.x 會直接放棄解析整個程式,且不拋出任何錯誤:
(function f(){})(); // 有名函數表達式
alert(1); // 因前面表達式導致整個程式失敗,此行永遠不會執行
經過測試可以總結出:如果有名函數表達式不是賦值表達式的一部分,Safari 解析它就會失敗。因此,將有名函數表達式放入賦值中能讓 Safari「開心」:
(function f(){}); // 失敗
var f = function f(){}; // 成功
(function(){
return function f(){}; // 失敗
})();
(function(){
return (f = function f(){}); // 成功
})();
setTimeout(function f(){ }, 100); // 失敗
這意味著我們不能用「直接返回有名函數表達式而無賦值」這種常見模式,而應改用稍微冗長但相容的替代寫法:
(function(){
var f;
if (featureTest) {
f = function f(){};
}
else {
f = function f(){};
}
return f;
})();
另外值得一提的是,在 Safari 2.x 中宣告有名函數表達式時,函數的表示法並不包含函數標識符:
var f = function g(){};
String(g); // function () { }
這並非大問題,因為函數反編譯在任何情況下都不應被過度依賴。
var fn = (function(){
// 宣告一個變數用來賦值函數物件
var f;
// 條件式地建立有名函數並將其引用賦值給 f
if (true) {
f = function F(){ }
}
else if (false) {
f = function F(){ }
}
else {
f = function F(){ }
}
// 給對應函數名的變數賦值 null,
// 使其可被垃圾回收
var F = null;
// 返回條件式定義的函數
return f;
})();
最後,來看看在真實場景中如何應用這套技術,比如編寫一個跨瀏覽器的 addEvent 函數:
// 1) 用一個獨立作用域封裝聲明
var addEvent = (function(){
var docEl = document.documentElement;
// 2) 宣告一個變數用來賦值函數
var fn;
if (docEl.addEventListener) {
// 3) 確保給函數一個描述性的標識符
fn = function addEvent(element, eventName, callback) {
element.addEventListener(eventName, callback, false);
}
}
else if (docEl.attachEvent) {
fn = function addEvent(element, eventName, callback) {
element.attachEvent('on' + eventName, callback);
}
}
else {
fn = function addEvent(element, eventName, callback) {
element['on' + eventName] = callback;
}
}
// 4) 清除 JScript 創建的 addEvent 函數
// 記得在賦值前加上 var,或在函數頂端聲明 addEvent
var addEvent = null;
// 5) 最後返回 fn 所引用的函數
return fn;
})();
值得一提的是,其實還有其他方式能在呼叫堆疊上顯示描述性名稱,而不必使用有名函數表達式。首先,通常可以用函數聲明而非表達式來定義函數——這只適用於你不需要建立多個函數的情況:
var hasClassName = (function(){
var cache = { };
// 使用函數聲明
function hasClassName(element, className) {
var _className = '(?:^|\\s+)' + className + '(?:\\s+|$)';
var re = cache[_className] || (cache[_className] = new RegExp(_className));
return re.test(element.className);
}
return hasClassName;
})();
這種方式顯然不適用於函數分叉的場景。不過,還有一個源自 Tobie Langel 的巧妙模式——用函數聲明預先定義所有函數,但給它們稍微不同的標識符:
var addEvent = (function(){
var docEl = document.documentElement;
function addEventListener(){ /* ... */ }
function attachEvent(){ /* ... */ }
function addEventAsProperty(){ /* ... */ }
if (typeof docEl.addEventListener != 'undefined') {
return addEventListener;
}
elseif (typeof docEl.attachEvent != 'undefined') {
return attachEvent;
}
return addEventAsProperty;
})();
這是一個優雅的方案,但也有其缺點。首先,使用不同的標識符會犧牲命名的一致性;其次,預先定義所有變體會隱含地建立 N-1 個未被使用的函數,它們會被「困」在返回函數的閉包中而佔用記憶體。不過,只要函數不是重複地(執行時)建立,而僅在載入時建立一次,這點額外開銷通常無需擔心。