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

// 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内部）

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

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

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

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

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

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

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

  ( 1 );

// 下面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 */ }() // 需要传递参数时，要添加()

 // 下面的代码输出的结果并不是你想的那样，因为变量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' );

  }

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

  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(); }());

// 创建一个立即被调用的匿名函数表达式，并且把函数表达式的返回值赋值给一个变量。这种方式裁掉了名叫`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 未定义 (只在闭包中存在)