深入理解JavaScript系列(2):揭秘命名函數表達式 – Javascript教程_JS教程_技術文章 – 程式設計聯盟

前言
網上還沒用發現有人對命名函數表達式進去重復深入的討論,正因為如此,網上出現瞭各種各樣的誤解,本文將從原理和實踐兩個方面來探討JavaScript關於命名函數表達式的優缺點。

簡單的說,命名函數表達式隻有一個用戶,那就是在Debug或者Profiler分析的時候來描述函數的名稱,也可以使用函數名實現遞歸,但很快你就會發現其實是不切實際的。當然,如果你不關註調試,那就沒什麼可擔心的瞭,否則,如果你想瞭解兼容性方面的東西的話,你還是應該繼續往下看看。

我們先開始看看,什麼叫函數表達式,然後再說一下現代調試器如何處理這些表達式,如果你已經對這方面很熟悉的話,請直接跳過此小節。

函數表達式和函數聲明
在ECMAScript中,創建函數的最常用的兩個方法是函數表達式和函數聲明,兩者期間的區別是有點暈,因為ECMA規范隻明確瞭一點:函數聲明必須帶有標示符(Identifier)(就是大傢常說的函數名稱),而函數表達式則可以省略這個標示符:

  函數聲明:

  function 函數名稱 (參數:可選){ 函數體 }

  函數表達式:

  function 函數名稱(可選)(參數:可選){ 函數體 }

所以,可以看出,如果不聲明函數名稱,它肯定是表達式,可如果聲明瞭函數名稱的話,如何判斷是函數聲明還是函數表達式呢?ECMAScript是通過上下文來區分的,如果function foo(){}是作為賦值表達式的一部分的話,那它就是一個函數表達式,如果function foo(){}被包含在一個函數體內,或者位於程序的最頂部的話,那它就是一個函數聲明。

  function foo(){} // 聲明,因為它是程序的一部分  var bar = function foo(){}; // 表達式,因為它是賦值表達式的一部分  new function bar(){}; // 表達式,因為它是new表達式  (function(){    function bar(){} // 聲明,因為它是函數體的一部分  })();復制代碼
還有一種函數表達式不太常見,就是被括號括住的(function foo(){}),他是表達式的原因是因為括號 ()是一個分組操作符,它的內部隻能包含表達式,我們來看幾個例子:

  function foo(){} // 函數聲明  (function foo(){}); // 函數表達式:包含在分組操作符內    try {    (var x = 5); // 分組操作符,隻能包含表達式而不能包含語句:這裡的var就是語句  } catch(err) {    // SyntaxError  }復制代碼
你可以會想到,在使用eval對JSON進行執行的時候,JSON字符串通常被包含在一個圓括號裡:eval('(' + json + ')'),這樣做的原因就是因為分組操作符,也就是這對括號,會讓解析器強制將JSON的花括號解析成表達式而不是代碼塊。

  try {    { "x": 5 }; // "{" 和 "}" 做解析成代碼塊  } catch(err) {    // SyntaxError  }    ({ "x": 5 }); // 分組操作符強制將"{" 和 "}"作為對象字面量來解析復制代碼

表達式和聲明存在著十分微妙的差別,首先,函數聲明會在任何表達式被解析和求值之前先被解析和求值,即使你的聲明在代碼的最後一行,它也會在同作用域內第一個表達式之前被解析/求值,參考如下例子,函數fn是在alert之後聲明的,但是在alert執行的時候,fn已經有定義瞭:

  alert(fn());  function fn() {    return 'Hello world!';  }復制代碼
另外,還有一點需要提醒一下,函數聲明在條件語句內雖然可以用,但是沒有被標準化,也就是說不同的環境可能有不同的執行結果,所以這樣情況下,最好使用函數表達式:

  // 千萬別這樣做!  // 因為有的瀏覽器會返回first的這個function,而有的瀏覽器返回的卻是第二個  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();復制代碼

函數聲明的實際規則如下:

函數聲明隻能出現在程序或函數體內。從句法上講,它們 不能出現在Block(塊)({ … })中,例如不能出現在 if、while 或 for 語句中。因為 Block(塊) 中隻能包含Statement語句, 而不能包含函數聲明這樣的源元素。另一方面,仔細看一看規則也會發現,唯一可能讓表達式出現在Block(塊)中情形,就是讓它作為表達式語句的一部分。但是,規范明確規定瞭表達式語句不能以關鍵字function開頭。而這實際上就是說,函數表達式同樣也不能出現在Statement語句或Block(塊)中(因為Block(塊)就是由Statement語句構成的)。

 

函數語句
在ECMAScript的語法擴展中,有一個是函數語句,目前隻有基於Gecko的瀏覽器實現瞭該擴展,所以對於下面的例子,我們僅是抱著學習的目的來看,一般來說不推薦使用(除非你針對Gecko瀏覽器進行開發)。

1.一般語句能用的地方,函數語句也能用,當然也包括Block塊中:

  if (true) {    function f(){ }  }  else {    function f(){ }  }復制代碼
2.函數語句可以像其他語句一樣被解析,包含基於條件執行的情形

  if (true) {    function foo(){ return 1; }  }  else {    function foo(){ return 2; }  }  foo(); // 1  // 註:其它客戶端會將foo解析成函數聲明   // 因此,第二個foo會覆蓋第一個,結果返回2,而不是1復制代碼
3.函數語句不是在變量初始化期間聲明的,而是在運行時聲明的——與函數表達式一樣。不過,函數語句的標識符一旦聲明能在函數的整個作用域生效瞭。標識符有效性正是導致函數語句與函數表達式不同的關鍵所在(下一小節我們將會展示命名函數表達式的具體行為)。

  // 此刻,foo還沒用聲明  typeof foo; // "undefined"  if (true) {    // 進入這裡以後,foo就被聲明在整個作用域內瞭    function foo(){ return 1; }  }  else {    // 從來不會走到這裡,所以這裡的foo也不會被聲明    function foo(){ return 2; }  }  typeof foo; // "function"  復制代碼
不過,我們可以使用下面這樣的符合標準的代碼來模式上面例子中的函數語句:

  var foo;  if (true) {    foo = function foo(){ return 1; };  }  else {    foo = function foo() { return 2; };  }復制代碼
4.函數語句和函數聲明(或命名函數表達式)的字符串表示類似,也包括標識符:

  if (true) {    function foo(){ return 1; }  }  String(foo); // function foo() { return 1; }復制代碼
5.另外一個,早期基於Gecko的實現(Firefox 3及以前版本)中存在一個bug,即函數語句覆蓋函數聲明的方式不正確。在這些早期的實現中,函數語句不知何故不能覆蓋函數聲明:

  // 函數聲明  function foo(){ return 1; }  if (true) {    // 用函數語句重寫    function foo(){ return 2; }  }  foo(); // FF3以下返回1,FF3.5以上返回2    // 不過,如果前面是函數表達式,則沒用問題  var foo = function(){ return 1; };  if (true) {    function foo(){ return 2; }  }  foo(); // 所有版本都返回2復制代碼
再次強調一點,上面這些例子隻是在某些瀏覽器支持,所以推薦大傢不要使用這些,除非你就在特性的瀏覽器上做開發。

命名函數表達式
函數表達式在實際應用中還是很常見的,在web開發中友個常用的模式是基於對某種特性的測試來偽裝函數定義,從而達到性能優化的目的,但由於這種方式都是在同一作用域內,所以基本上一定要用函數表達式:

  // 該代碼來自Garrett Smith的APE Javascript library庫(http://dhtmlkitchen.com/ape/)   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();  // 這裡我們使用瞭3個帶名字的函數聲明  // 所以當調試器走到debugger語句的時候,Firebug的調用棧上看起來非常清晰明瞭   // 因為很明白地顯示瞭名稱  baz  bar  foo  expr_test.html()復制代碼
通過查看調用棧的信息,我們可以很明瞭地知道foo調用瞭bar, bar又調用瞭baz(而foo本身有在expr_test.html文檔的全局作用域內被調用),不過,還有一個比較爽地方,就是剛才說的Firebug為匿名表達式取名的功能:

  function foo(){    return bar();  }  var bar = function(){    return baz();  }  function baz(){    debugger;  }  foo();  // Call stack  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();  // Call stack  baz  (?)() // 這裡可是問號哦  foo  expr_test.html()復制代碼
另外,當把函數賦值給多個變量的時候,也會出現令人鬱悶的問題:

  function foo(){    return baz();  }  var bar = function(){    debugger;  };  var baz = bar;  bar = function() {     alert('spoofed');  };  foo();  // Call stack:  bar()  foo  expr_test.html()復制代碼
這時候,調用棧顯示的是foo調用瞭bar,但實際上並非如此,之所以有這種問題,是因為baz和另外一個包含alert('spoofed')的函數做瞭引用交換所導致的。

歸根結底,隻有給函數表達式取個名字,才是最委托的辦法,也就是使用命名函數表達式。我們來使用帶名字的表達式來重寫上面的例子(註意立即調用的表達式塊裡返回的2個函數的名字都是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()復制代碼
OK,又學瞭一招吧?不過在高興之前,我們再看看不同尋常的JScript吧。

JScript的Bug
比較惡的是,IE的ECMAScript實現JScript嚴重混淆瞭命名函數表達式,搞得現很多人都出來反對命名函數表達式,而且即便是最新的一版(IE8中使用的5.8版)仍然存在下列問題。

下面我們就來看看IE在實現中究竟犯瞭那些錯誤,俗話說知已知彼,才能百戰不殆。我們來看看如下幾個例子:

例1:函數表達式的標示符泄露到外部作用域

    var f = function g(){};    typeof g; // "function"復制代碼
上面我們說過,命名函數表達式的標示符在外部作用域是無效的,但JScript明顯是違反瞭這一規范,上面例子中的標示符g被解析成函數對象,這就亂瞭套瞭,很多難以發現的bug都是因為這個原因導致的。

註:IE9貌似已經修復瞭這個問題

例2:將命名函數表達式同時當作函數聲明和函數表達式

    typeof g; // "function"    var f = function g(){};復制代碼
特性環境下,函數聲明會優先於任何表達式被解析,上面的例子展示的是JScript實際上是把命名函數表達式當成函數聲明瞭,因為它在實際聲明之前就解析瞭g。

這個例子引出瞭下一個例子。
例3:命名函數表達式會創建兩個截然不同的函數對象!

    var f = function g(){};    f === g; // false    f.expando = 'foo';    g.expando; // undefined復制代碼
看到這裡,大傢會覺得問題嚴重瞭,因為修改任何一個對象,另外一個沒有什麼改變,這太惡瞭。通過這個例子可以發現,創建2個不同的對象,也就是說如果你想修改f的屬性中保存某個信息,然後想當然地通過引用相同對象的g的同名屬性來使用,那問題就大瞭,因為根本就不可能。

再來看一個稍微復雜的例子:

例4:僅僅順序解析函數聲明而忽略條件語句塊

    var f = function g() {      return 1;    };    if (false) {      f = function g(){        return 2;      };    }    g(); // 2復制代碼
這個bug查找就難多瞭,但導致bug的原因卻非常簡單。首先,g被當作函數聲明解析,由於JScript中的函數聲明不受條件代碼塊約束,所以在這個很惡的if分支中,g被當作另一個函數function g(){ return 2 },也就是又被聲明瞭一次。然後,所有“常規的”表達式被求值,而此時f被賦予瞭另一個新創建的對象的引用。由於在對表達式求值的時候,永遠不會進入“這個可惡if分支,因此f就會繼續引用第一個函數function g(){ return 1 }。分析到這裡,問題就很清楚瞭:假如你不夠細心,在f中調用瞭g,那麼將會調用一個毫不相幹的g函數對象。

你可能會文,將不同的對象和arguments.callee相比較時,有什麼樣的區別呢?我們來看看:

 var f = function g(){    return [      arguments.callee == f,      arguments.callee == g    ];  };  f(); // [true, false]  g(); // [false, true]復制代碼
可以看到,arguments.callee的引用一直是被調用的函數,實際上這也是好事,稍後會解釋。

還有一個有趣的例子,那就是在不包含聲明的賦值語句中使用命名函數表達式:

  (function(){    f = function f(){};  })();復制代碼
按照代碼的分析,我們原本是想創建一個全局屬性f(註意不要和一般的匿名函數混淆瞭,裡面用的是帶名字的生命),JScript在這裡搗亂瞭一把,首先他把表達式當成函數聲明解析瞭,所以左邊的f被聲明為局部變量瞭(和一般的匿名函數裡的聲明一樣),然後在函數執行的時候,f已經是定義過的瞭,右邊的function f(){}則直接就賦值給局部變量f瞭,所以f根本就不是全局屬性。

 

瞭解瞭JScript這麼變態以後,我們就要及時預防這些問題瞭,首先防范標識符泄漏帶外部作用域,其次,應該永遠不引用被用作函數名稱的標識符;還記得前面例子中那個討人厭的標識符g嗎?——如果我們能夠當g不存在,可以避免多少不必要的麻煩哪。因此,關鍵就在於始終要通過f或者arguments.callee來引用函數。如果你使用瞭命名函數表達式,那麼應該隻在調試的時候利用那個名字。最後,還要記住一點,一定要把命名函數表達式聲明期間錯誤創建的函數清理幹凈。

對於,上面最後一點,我們還得再解釋一下。

JScript的內存管理
知道瞭這些不符合規范的代碼解析bug以後,我們如果用它的話,就會發現內存方面其實是有問題的,來看一個例子:

  var f = (function(){    if (true) {      return function g(){};    }    return function g(){};  })();復制代碼
我們知道,這個匿名函數調用返回的函數(帶有標識符g的函數),然後賦值給瞭外部的f。我們也知道,命名函數表達式會導致產生多餘的函數對象,而該對象與返回的函數對象不是一回事。所以這個多餘的g函數就死在瞭返回函數的閉包中瞭,因此內存問題就出現瞭。這是因為if語句內部的函數與g是在同一個作用域中被聲明的。這種情況下 ,除非我們顯式斷開對g函數的引用,否則它一直占著內存不放。

  var f = (function(){    var f, g;    if (true) {      f = function g(){};    }    else {      f = function g(){};    }    // 設置g為null以後它就不會再占內存瞭    g = null;    return f;  })();復制代碼
通過設置g為null,垃圾回收器就把g引用的那個隱式函數給回收掉瞭,為瞭驗證我們的代碼,我們來做一些測試,以確保我們的內存被回收瞭。

測試

測試很簡單,就是命名函數表達式創建10000個函數,然後把它們保存在一個數組中。等一會兒以後再看這些函數到底占用瞭多少內存。然後,再斷開這些引用並重復這一過程。下面是測試代碼:

  function createFn(){    return (function(){      var f;      if (true) {        f = function F(){          return 'standard';        };      }      else if (false) {        f = function F(){          return 'alternative';        };      }      else {        f = function F(){          return 'fallback';        };      }      // var F = null;      return f;    })();  }  var arr = [ ];  for (var i=0; i<10000; i++) {    arr[i] = createFn();  }復制代碼
通過運行在Windows XP SP2中的任務管理器可以看到如下結果:

  IE6:    without `null`:   7.6K -> 20.3K    with `null`:      7.6K -> 18K  IE7:    without `null`:   14K -> 29.7K    with `null`:      14K -> 27K復制代碼
如我們所料,顯示斷開引用可以釋放內存,但是釋放的內存不是很多,10000個函數對象才釋放大約3M的內存,這對一些小型腳本不算什麼,但對於大型程序,或者長時間運行在低內存的設備裡的時候,這是非常有必要的。

 

關於在Safari 2.x中JS的解析也有一些bug,但介於版本比較低,所以我們在這裡就不介紹瞭,大傢如果想看的話,請仔細查看英文資料。

SpiderMonkey的怪癖
大傢都知道,命名函數表達式的標識符隻在函數的局部作用域中有效。但包含這個標識符的局部作用域又是什麼樣子的嗎?其實非常簡單。在命名函數表達式被求值時,會創建一個特殊的對象,該對象的唯一目的就是保存一個屬性,而這個屬性的名字對應著函數標識符,屬性的值對應著那個函數。這個對象會被註入到當前作用域鏈的前端。然後,被“擴展”的作用域鏈又被用於初始化函數。

在這裡,有一點十分有意思,那就是ECMA-262定義這個(保存函數標識符的)“特殊”對象的方式。標準說“像調用new Object()表達式那樣”創建這個對象。如果從字面上來理解這句話,那麼這個對象就應該是全局Object的一個實例。然而,隻有一個實現是按照標準字面上的要求這麼做的,這個實現就是SpiderMonkey。因此,在SpiderMonkey中,擴展Object.prototype有可能會幹擾函數的局部作用域:

  Object.prototype.x = 'outer';    (function(){        var x = 'inner';        /*      函數foo的作用域鏈中有一個特殊的對象——用於保存函數的標識符。這個特殊的對象實際上就是{ foo: <function object> }。      當通過作用域鏈解析x時,首先解析的是foo的局部環境。如果沒有找到x,則繼續搜索作用域鏈中的下一個對象。下一個對象      就是保存函數標識符的那個對象——{ foo: <function object> },由於該對象繼承自Object.prototype,所以在此可以找到x。      而這個x的值也就是Object.prototype.x的值(outer)。結果,外部函數的作用域(包含x = 'inner'的作用域)就不會被解析瞭。    */        (function foo(){            alert(x); // 提示框中顯示:outer        })();  })();復制代碼
不過,更高版本的SpiderMonkey改變瞭上述行為,原因可能是認為那是一個安全漏洞。也就是說,“特殊”對象不再繼承Object.prototype瞭。不過,如果你使用Firefox 3或者更低版本,還可以“重溫”這種行為。

另一個把內部對象實現為全局Object對象的是黑莓(Blackberry)瀏覽器。目前,它的活動對象(Activation Object)仍然繼承Object.prototype。可是,ECMA-262並沒有說活動對象也要“像調用new Object()表達式那樣”來創建(或者說像創建保存NFE標識符的對象一樣創建)。 人傢規范隻說瞭活動對象是規范中的一種機制。

那我們就來看看黑莓裡都發生瞭什麼:

  Object.prototype.x = 'outer';    (function(){        var x = 'inner';        (function(){            /*      在沿著作用域鏈解析x的過程中,首先會搜索局部函數的活動對象。當然,在該對象中找不到x。      可是,由於活動對象繼承自Object.prototype,因此搜索x的下一個目標就是Object.prototype;而      Object.prototype中又確實有x的定義。結果,x的值就被解析為——outer。跟前面的例子差不多,      包含x = 'inner'的外部函數的作用域(活動對象)就不會被解析瞭。      */            alert(x); // 顯示:outer          })();  })();復制代碼
不過神奇的還是,函數中的變量甚至會與已有的Object.prototype的成員發生沖突,來看看下面的代碼:

  (function(){        var constructor = function(){ return 1; };        (function(){            constructor(); // 求值結果是{}(即相當於調用瞭Object.prototype.constructor())而不是1            constructor === Object.prototype.constructor; // true      toString === Object.prototype.toString; // true            // ……          })();  })();復制代碼
要避免這個問題,要避免使用Object.prototype裡的屬性名稱,如toString, valueOf, hasOwnProperty等等。

 

JScript解決方案

  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;  })();復制代碼
顯然,當存在多個分支函數定義時,這個方案就不行瞭。不過有種模式貌似可以實現:那就是提前使用函數聲明來定義所有函數,並分別為這些函數指定不同的標識符:

  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;  })();復制代碼
雖然這個方案很優雅,但也不是沒有缺點。第一,由於使用不同的標識符,導致喪失瞭命名的一致性。且不說這樣好還是壞,最起碼它不夠清晰。有人喜歡使用相同的名字,但也有人根本不在乎字眼上的差別。可畢竟,不同的名字會讓人聯想到所用的不同實現。例如,在調試器中看到attachEvent,我們就知 道addEvent是基於attachEvent的實現。當 然,基於實現來命名的方式也不一定都行得通。假如我們要提供一個API,並按照這種方式把函數命名為inner。那麼API用戶的很容易就會被相應實現的 細節搞得暈頭轉向。

要解決這個問題,當然就得想一套更合理的命名方案瞭。但關鍵是不要再額外制造麻煩。我現在能想起來的方案大概有如下幾個:

  'addEvent', 'altAddEvent', 'fallbackAddEvent'  // 或者  'addEvent', 'addEvent2', 'addEvent3'  // 或者  'addEvent_addEventListener', 'addEvent_attachEvent', 'addEvent_asProperty'復制代碼
另外,這種模式還存在一個小問題,即增加內存占用。提前創建N個不同名字的函數,等於有N-1的函數是用不到的。具體來講,如果document.documentElement 中包含attachEvent,那麼addEventListener 和addEventAsProperty則根本就用不著瞭。可是,他們都占著內存哪;而且,這些內存將永遠都得不到釋放,原因跟JScript臭哄哄的命名表達式相同——這兩個函數都被“截留”在返回的那個函數的閉包中瞭。

不過,增加內存占用這個問題確實沒什麼大不瞭的。如果某個庫——例如Prototype.js——采用瞭這種模式,無非也就是多創建一兩百個函數而已。隻要不是(在運行時)重復地創建這些函數,而是隻(在加載時)創建一次,那麼就沒有什麼好擔心的。

WebKit的displayName
WebKit團隊在這個問題采取瞭有點兒另類的策略。介於匿名和命名函數如此之差的表現力,WebKit引入瞭一個“特殊的”displayName屬性(本質上是一個字符串),如果開發人員為函數的這個屬性賦值,則該屬性的值將在調試器或性能分析器中被顯示在函數“名稱”的位置上。Francisco Tolmasky詳細地解釋瞭這個策略的原理和實現。

 

未來考慮
將來的ECMAScript-262第5版(目前還是草案)會引入所謂的嚴格模式(strict mode)。開啟嚴格模式的實現會禁用語言中的那些不穩定、不可靠和不安全的特性。據說出於安全方面的考慮,arguments.callee屬性將在嚴格模式下被“封殺”。因此,在處於嚴格模式時,訪問arguments.callee會導致TypeError(參見ECMA-262第5版的10.6節)。而我之所以在此提到嚴格模式,是因為如果在基於第5版標準的實現中無法使用arguments.callee來執行遞歸操作,那麼使用命名函數表達式的可能性就會大大增加。從這個意義上來說,理解命名函數表達式的語義及其bug也就顯得更加重要瞭。

 

  // 此前,你可能會使用arguments.callee  (function(x) {    if (x <= 1) return 1;    return x * arguments.callee(x – 1);  })(10);    // 但在嚴格模式下,有可能就要使用命名函數表達式  (function factorial(x) {    if (x <= 1) return 1;    return x * factorial(x – 1);  })(10);    // 要麼就退一步,使用沒有那麼靈活的函數聲明  function factorial(x) {    if (x <= 1) return 1;    return x * factorial(x – 1);  }  factorial(10);復制代碼

摘自 湯姆大叔的博客

發佈留言