// 因为返回的函数有权访问私有变量 `i`

  function makeCounter() {

    // `i` 只能在 `makeCounter`内被访问.

    var i = 0;

    return function() {

      console.log( ++i );

    };

  }

  // 注意 `counter` 和 `counter2` 都有私有的作用域 `i`.

  var counter = makeCounter();

  counter(); // logs: 1

  counter(); // logs: 2

  var counter2 = makeCounter();

  counter2(); // logs: 1

  counter2(); // logs: 2

  i; // ReferenceError: i 未定义 (只存在 makeCounter 内部)

  // 像这样定义的函数可以在函数名后放置 () 来执行

  // 比如 foo(), 因为 foo 只是函数表达式 `function() { /* code */ }`的引用

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

  // ...是不是只在函数表达式之后放置 () 就能执行?

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

  // 现在这个函数声明的语法是正确的，但还是有报错

  // 表达式后面的括号是非法的， 因为分组运算符必须包含表达式

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

  // 如果你在括号内放置了表达式， 没有错误抛出...

  // 但是函数也不会执行， 因为:

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

  // 它与一个函数声明后面放一个完全无关的表达式是一样的:

  function foo(){ /* code */ }

  ( 1 );

// 以下的任何一种方式都可以立即执行函数表达式，利用函数的执行环境

// 创建私有作用域

(function(){ /* code */ }()); // Crockford 推荐这个

(function(){ /* code */ })(); // 这个同样运行正常

// 因为括号和强制运算符的目的就是区分函数表达式和函数声明

// 它们会在解析器解析表达式时被忽略（但是请看下面的“重要提示”）

var i = function(){ return 10; }();

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

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

// 如果你不关心函数返回值或者你的代码变得难以阅读

// 你可以在函数前面加一个一元运算符

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

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

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

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

// 下面是另一种变体， from @kuvos

// 我不确定使用 `new` 关键字是否有性能影响， 但是能够正常运行

// http://twitter.com/kuvos/status/18209252090847232

new function(){ /* code */ }

new function(){ /* code */ }() // 只需要使用括号传递参数

// 以下程序的运行结果和你想象的并不一样, 因为 `i` 的值

// 不会被锁定。相反，当点击每个链接的时候 (循环已经

// 结束), 会显示元素的总数, 因为那才是

// 点击时 `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` 被锁定。 循环结束之后,

// 尽管 `i` 的值是元素总数, 但是在 IIFE 中

// `lockedInIndex` 的值是函数表达式调用时传入的(`i`)的值

// 因此当点击链接时, 显示的值是正确的。

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 , 只是包含 (返回)

// 点击处理函数, 并不是整个 `addEventListener` 声明

// 无论哪种方式，两个示例都使用

// IIFE, 我发现前面的例子更易读懂

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` 标识符实际引用它的时候。如果你把`foo` 换成

// 别的东西, 你可能会有一个 "用于自执行" 的匿名函数。

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

// 有些人把这个称为 "自执行匿名函数" ，其实它并

// 不是自执行, 因为它没有调用自身。它只是

// 立即调用。

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

// 给函数表达式添加一个标识符 (因此创建了一个命名

// 函数表达式) ，调试时会非常有用。一旦命名,

// 函数不再是匿名的。

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

// IIFE 也可以自执行, 尽管这并不是最

// 有用的方式。

(function(){ arguments.callee(); }());

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

// 最后需要注意的一点: 这在 BlackBerry 5 中会报错, 因为

// 在一个命名函数表达式中, 函数名是 undefined。很奇怪，对吧？

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

// 创建一个立即执行的匿名函数表达式, 然后

// 将它的 *返回值* 赋给一个变量。这种方法无须再

// 创建一个 `makeWhatever` 函数的引用。

//

// 如同上面 "关于括号的注意事项" 中提到的一样， 尽管括号在函数

// 表达式中不是必须添加的, 但是按照习惯还是应该添加括号，

// 因为这可以更清晰的表示出赋值给一个变量的是

// 函数的 *结果* 而不是函数自身

var counter = (function(){

  var i = 0;

  return {

    get: function(){

      return i;

    },

    set: function( val ){

      i = val;

    },

    increment: function() {

      return ++i;

    }

  };

}());

// `counter` 是一个有属性的对象, 它的属性都是方法

counter.get(); //

counter.set( 3 );

counter.increment(); //

counter.increment(); //

counter.i; // undefined (`i` 不是返回对象的属性)

i; // ReferenceError: i 未定义 (它只存在于闭包内)