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的方式，组织整个代码模块。

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

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

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

旁白：函数，圆括号，语法错误

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

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

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

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

最终的旁白: The Module Pattern

Further reading（更多相关阅读）

你可能感兴趣的:(Immediately-Invoked Function Expression (IIFE)即调函数表达式)