DIV CSS 佈局教程網

有名函數表達式全面解析(翻譯教程)
編輯:關於JavaScript     

在 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()

JScript 的 Bug

在我們歡呼雀躍之前,還是先來看看 IE 的 ECMAScript 實作——JScript 的表現。遺憾的是,JScript 對有名函數表達式的處理簡直是一團糟,這也正是它被許多人「勸退」的根源。

示例 #1:函數表達式標識符洩漏到外層作用域

var f = function g(){};
typeof g; // "function"

前面提到,有名函數表達式的標識符不應在外層作用域中可見。但 JScript 並不買帳——上面的 g 竟然解析為一個函數物件。這是最常見的差異,它會在無意間污染外層作用域(甚至可能是全域作用域),埋下難以追蹤的 bug 伏筆。

示例 #2:有名函數表達式被同時當作函數聲明與函數表達式處理

typeof g; // "function"
var f = function g(){};

JScript 實際上把有名函數表達式當作函數聲明來對待,會在「真正的聲明」發生前就先行解析 g。

示例 #3:有名函數表達式創建了兩個不同的函數物件!

var f = function g(){};
f === g; // false

f.expando = 'foo';
g.expando; // undefined

這裡事情變得棘手了。我們必須面對兩個截然不同的物件——擴充其中一個並不會影響另一個。如果你打算在 f 的屬性中快取一些資料,卻誤以為 g 指向同一物件而去存取,就會引發各種難題。

示例 #4:函數聲明按順序解析,不受條件塊影響

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 的記憶體管理

熟悉 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 的 Bug

較少為人知的是,舊版 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 個未被使用的函數,它們會被「困」在返回函數的閉包中而佔用記憶體。不過,只要函數不是重複地(執行時)建立,而僅在載入時建立一次,這點額外開銷通常無需擔心。

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