Immediately-Invoked Function Expression (IIFE)即调函数表达式

以防你没有注意到,我先声明下:我总是要求术语。所以,在听到许多次 流行的,但是让人误解的 JavaScript术语“self-executing anonymous function自我执行匿名函数(或者self-invoked anonymous function自我调用匿名函数)”之后,最终我决定把我的想法组织成一篇文章。 除了提供一些关于IIFE这个模式的非常详细的信息,我也在‘我们该如何称呼它’上 做了建议。此外,如果你想跳到前面,你可以只查看下面的Immediately-Invoked Function Expressions部分,但是我建议读完整篇文章。 这篇文章不是想表达“我是对的,你是错的”,这类的事情。我是真的对“帮助其他人理解潜在地复杂概念”感兴趣,并且觉得“使用一致和准确的术语是人们可以做的促进理解 最简单的事情”。

So,what’s this all about, anyways?(那么,这都是关于什么?)

在JavaScript中,当每个function被调用时,会创建一个新的执行上下文。因为在函数内定义的变量和函数只能在该函数内被访问(也就是在函数外不能访问这些变量和函数),上下文提供了一个非常容易的创建privacy的方法。

// Because this function returns another function that has access to the
// "private" var i, the returned function is, effectively, "privileged."
因为makeCounter函数返回了一个匿名函数,该匿名函数可以访问私有变量i,被返回的匿名函数实际上是有特权的。

  function makeCounter() {
    // `i` is only accessible inside `makeCounter`.
    //变量i只能在makeCounter内访问
    var i = 0;

    return function() {
      console.log( ++i );
    };
  }

  // Note that `counter` and `counter2` each have their own scoped `i`.
  //注意counter和counter在他们各自的作用域内有自己的变量i。

  var counter = makeCounter();
  counter(); // logs: 1
  counter(); // logs: 2

  var counter2 = makeCounter();
  counter2(); // logs: 1
  counter2(); // logs: 2

  i; // ReferenceError: i is not defined (it only exists inside makeCounter)
     //ReferenceError:i没有被定义(i只存在于makeCounter内部)

在很多情况下,不管你的makeCounter函数返回什么,你都不需要函数返回值的多个实例,并且使用单个的实例就可以应付。而在其它情况下,你根本就不会显式地返回一个值。

The heart of the matter(事情的核心)

现在,你是像这样(function foo(){})还是像这样(var foo = function(){})定义一个函数,你最终得到的是一个函数标识符。你可以通过在其后添加2个圆括号来调用该函数(像foo()这样)。

//因为: foo只是对函数表达式(function() {/* code */})的一个引用,既然可以在foo后添加()来调用函数,

  var foo = function(){ /* code */ }

  //那么通过在函数表达式后添加()来调用函数表达式不是顺理成章的?

  function(){ /* code */ }(); // SyntaxError: Unexpected token (

如你所见,这里哽住了。当解释器‘在 全局作用域或函数作用域内’遇到关键字function时,默认情况下,解释器会把它看作是函数声明,而不是看作函数表达式。如果你没有明确地告诉解释器去期待一个表达式,解释器会把它看到的认为是一个没有函数名的函数声明,并抛出一个SyntaxError异常(因为函数声明需要有函数名)。

旁白:函数,圆括号,语法错误

有趣的是,如果你为函数指定一个函数名,并在函数后添加(),解释器仍然会抛出一个语法错误的提示,但是这次抛出语法错的原因不同。虽然在函数表达式后添加的(),想表明函数表达式是一个将被调用的函数,但是放置在函数声明之后的()是完全独立于‘()之前的函数声明’的,这里的()仅仅只是一个分组操作符而已(用来控制运算优先级的方式)。

 //虽然这个函数声明在语法上是有效的,但它仍是一个声明。接下来的一对()是无效的,因为()作为分组操作符是需要包含一个表达式的。
 
  function foo(){ /* code */ }(); // SyntaxError: Unexpected token )

  //现在,如果你在()中放一个表达式,就没有异常被抛出了。但是函数仍然不会被执行,因为下面这行代码:
  
  function foo(){ /* code */ }( 1 );

  //等同于下面这行代码(一个函数声明之后跟随一个完全不相干的表达式):
  
  function foo(){ /* code */ }

  ( 1 );

Immediately-Invoked Function Expression (IIFE)即调函数表达式

所幸地是,这个语法错误的修复是很简单的。最被广泛接受的‘告知解释器去期待一个函数表达式’的方法是“用()包围函数声明”,因为在JavaScript中,声明是不能放在()内的,换句话说放在()内的都不是声明。此时此刻,当解释器遇到关键字function时,解释器知道把它解释为函数表达式,而不是函数声明。

// 下面2个模式中的任何一个都可以使函数表达式立刻被调用,并利用函数的执行上下文去创建‘privacy’。

  (function(){ /* code */ }());
  
  (function(){ /* code */ })(); 

  //因为()的意义,或者说 强制转换操作符 的意义是 去除函数表达式和函数声明之间的歧义。当解释器已经明确期待一个表达式时,可以不用 加()来消除歧义(但是请阅读下面的impotant note)。
  
  var i = function(){ return 10; }();
  true && function(){ /* code */ }();
  0, function(){ /* code */ }();

  // 如果你不关心函数返回值,也不关心代码的可阅读性,你可以通过在函数前添加一个一元运算符前缀,来节省一个字节。

  !function(){ /* code */ }();
  ~function(){ /* code */ }();
  -function(){ /* code */ }();
  +function(){ /* code */ }();

  // 这儿有另外的变体,我不确定使用关键字`new`的性能影响,但是它确实起作用。

  new function(){ /* code */ }
  new function(){ /* code */ }() // 需要传递参数时,要添加()

An important note about those parens关于()的重要注释

在一些情况中,额外的包裹函数表达式的()是不必要的,因为解释器已经在期待一个表达式了,但是考虑到一致性,当赋值时最好还是加上(), 这样的()通常要表明的是‘函数表达式会被立即调用,变量会保存函数的结果,而不是函数本身’。这可以节省阅读你代码的某人 不得不滚动到可能是一个非常长的函数表达式末尾 查看函数表达式是否被调用 的麻烦。 作为首条准则,虽然编写不具歧义的代码在技术上可能是让JavaScript解释器不抛出语法错误异常,但是编写不具歧义的代码更是让其他的开发者不对你抛出‘什么鬼错误WTFError’异常。

Saving state with closures使用闭包保存状态

就像函数被调用时要传递参数一样,当立即调用一个函数表达式时,也需要传递参数。因为在一个函数中定义的任何函数,可以访问外层函数传进来的参数和变量(这个关系就是闭包),一个IIFE可以用来有效的锁定值和保存状态。 如果你想更多的了解闭包,可以阅读Closures explained with JavaScript

 // 下面的代码输出的结果并不是你想的那样,因为变量i的值没有被锁定。每个link被点击时(loop的执行已经结束),会弹出元素的总数目,因为在那时变量i的值就是元素的总数目。

  var elems = document.getElementsByTagName( 'a' );

  for ( var i = 0; i < elems.length; i++ ) {

    elems[ i ].addEventListener( 'click', function(e){
      e.preventDefault();
      alert( 'I am link #' + i );
    }, 'false' );

  }

  // 如下的代码的输出会跟你想的一样,因为在IIFE内,变量i的值被锁定在‘lockedInIndex’。在loop结束后,即使变量i的值是元素的总数目。在IIFE内,当函数表达式被调用时,lockedInIndex的值仍然是传递给lockInIndex的变量i的值。所以,当link被点击时,能弹出正确的值。

  var elems = document.getElementsByTagName( 'a' );

  for ( var i = 0; i < elems.length; i++ ) {

    (function( lockedInIndex ){

      elems[ i ].addEventListener( 'click', function(e){
        e.preventDefault();
        alert( 'I am link #' + lockedInIndex );
      }, 'false' );

    })( i );

  }

  // 你也可以像这样使用IIFE,只包围click处理函数,而不是整个‘addEventListener’。虽然2个例子都使用IIFE锁定变量i的值,但是我觉得前一种例子阅读性更好。
  
  var elems = document.getElementsByTagName( 'a' );

  for ( var i = 0; i < elems.length; i++ ) {

    elems[ i ].addEventListener( 'click', (function( lockedInIndex ){
      return function(e){
        e.preventDefault();
        alert( 'I am link #' + lockedInIndex );
      };
    })( i ), 'false' );

  }

在最后2个例子中要注意的是,lockedInIndex被叫做i 是没有任何问题的。但是使用一个不同名字的标识符作为函数参数,使得概念更容易解释。 IIFE最有利的副作用之一是,闭包可以被使用,而不用污染当前作用域。因为这个匿名的函数表达式被立即调用了。

那么“Self-executing anonymous function”错在哪儿?

你已经看到Self-executing anonymous function被提起了几次,但是以防它表述的不够清楚,我提倡使用术语“Immediately-Invoked Function Expression”,和“IIFE”(如果你喜欢首字母缩写的话)。 Immediately-Invoked Function Expression(即调函数表达式)是什么?它是一个被立即调用的函数表达式。就像它的名字想表达的那样。 我喜欢看到JavaScript社区成员在他们的文章和陈述中采用术语“Immediately-Invoked Function Expression”和“IIFE”,因为我感觉该术语使得理解这个概念更容易,并且因为术语“self-executing anonymous function”事实上是不准确的:

// 这是一个自我执行函数。它是个递归执行它自己的函数:

  function foo() { foo(); }

  // 这是个自我执行匿名函数。因为它没有函数名,所以它必须使用`arguments.callee(用来指明当前正在执行的函数)`属性来执行它自己。

  var foo = function() { arguments.callee(); };

  // 这可能是个自我执行匿名函数,只有当`foo`标识符引用它(匿名函数)的时候。

  var foo = function() { foo(); };

  // 有人称如下代码为自我执行匿名函数,即使它没有在执行自己,因为它没有调用它自己。然而,它是被立即调用的函数。

  (function(){ /* code */ }());

  // 给函数表达式添加一个标识符(因此创建了一个有名函数表达式),在debugging时是及其有用的。然而,一旦给了名字,函数就不再是匿名的了。
  
  (function foo(){ /* code */ }());

  // IIFEs也可以自我执行,尽管这或许不是最有用的模式。
  
  (function(){ arguments.callee(); }());
  (function foo(){ foo(); }());

  // 要注意的最后一件事:如下代码会在黑莓5中引发一个错误,因为在有名函数表达式中,foo未被定义。

  (function foo(){ foo(); }());

希望这些例子已经阐述清楚‘术语self-executing在某种程度上具有误导性’。因为IIFE不是‘函数调用自身’,也不是正在被执行的函数。当然,‘匿名’没必要指明,因为一个Immediately Invoked Function Expression(即调函数表达式)既可以有名称也可以匿名。至于我对invoked的偏爱超过于executed,这样押头韵;我认为IIFE不管是看起来还是听起来都好过IEFE。 所以,就是这,这就是我的想法。 有趣的事实:因为arguments.callee在ECMAScript 5的strict mode下是过期的,所以,在ECMAScript 5的strict mode下在技术层面上去创建一个自我执行的匿名函数是不可能的了。

最终的旁白: The Module Pattern

虽然我正在提出函数表达式,但是,如果我没提到Module Pattern,那我就是马虎的。如果你不熟悉JavaScript中的Module Pattern,Module Pattern和我的第一个例子类似,只不过函数返回的是‘对象’而不是‘函数’。(并且是作为‘单例singleton’被执行,就像如下的例子那样)。

// 创建一个立即被调用的匿名函数表达式,并且把函数表达式的返回值赋值给一个变量。这种方式裁掉了名叫`makeWhatever`的函数引用 这个中间商。

  // 就像在上面“impotent note”部分 解释的那样,即使在函数表达式周围不需要加上(),但是为了保持一致性,这样有助于阐述清楚:变量counter将被设置为函数的返回值,而不是函数自身。
  
  var counter = (function(){
    var i = 0;

    return {
      get: function(){
        return i;
      },
      set: function( val ){
        i = val;
      },
      increment: function() {
        return ++i;
      }
    };
  }());

  // `counter`是带有属性的object,在这个例子中,这些属性碰巧是方法。
  
  counter.get(); // 0
  counter.set( 3 );
  counter.increment(); // 4
  counter.increment(); // 5

  counter.i; // undefined (`i` 不是返回object的一个property)
  i; // ReferenceError: i 未定义 (只在闭包中存在)

这个Module Pattern方式不但是及其强大的,而且及其简单。使用非常少的代码,你就可以命名相关的方法和属性,以降低全局作用域污染和创建privacy的方式,组织整个代码模块。

Further reading(更多相关阅读)

希望这篇文章的信息够充足,并且回答了你的一些疑问。当然,如果跟‘你开始读这篇文章之前’相比,现在你的疑问更多了,你可以从下面这些文章中更多的了解functions和module pattern。

ECMA-262-3 in detail. Chapter 5. Functions. - Dmitry A. Soshnikov Functions and function scope - Mozilla Developer Network Named function expressions - Juriy “kangax” Zaytsev JavaScript Module Pattern: In-Depth - Ben Cherry Closures explained with JavaScript - Nick Morgan


本文翻译自:http://benalman.com/news/2010/11/immediately-invoked-function-expression/

转载请注明出处

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

扫码关注云+社区

领取腾讯云代金券