// Because this function returns another function that has access to the
   // "private" var i, the returned function is, effectively, "privileged."
  //因为这个函数返回可以访问“private” var 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`和`counter2`每个都有自己的作用域`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)28     // ReferenceError：i 没有定义（它只存在于makeCounter中）

 // Because a function defined like so can be invoked by putting () after
   // the function name, like foo(), and because foo is just a reference to
   // the function expression `function() { /* code */ }`...
   // 因为像这样定义的函数可以通过在函数名后加上()来调用，比如foo()，并且因为foo只是对函数表达式[function expression]`function(){/ * code * /}`的引用。

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

   // ...doesn't it stand to reason that the function expression itself can
   // be invoked, just by putting () after it?
   //…它是否能说明函数表达式本身可以被调用，仅仅通过在它之后放置()来调用它？

   function(){ /* code */ }(); // SyntaxError: Unexpected token (15                              //SyntaxError：意外的标记（

  // While this function declaration is now syntactically valid, it's still
   // a statement, and the following set of parens is invalid because the
   // grouping operator needs to contain an expression.
  // 虽然这个函数声明现在在语法上是有效的，但它仍然是一个声明，而下面的一组parens是无效的，因为分组操作符需要包含一个表达式。

   function foo(){ /* code */ }(); // SyntaxError: Unexpected token )
                                   //SyntaxError:意外的标记 )
   // Now, if you put an expression in the parens, no exception is thrown...
   // but the function isn't executed either, because this:
   //现在，如果你在parens中放置一个表达式，不会抛出异常......但是函数也不会执行，因为：

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

   // Is really just equivalent to this, a function declaration followed by a
   // completely unrelated expression:
   // 实际上与此相当，一个函数声明后跟一个完全不相关的表达式：

   function foo(){ /* code */ }

   ( 1 );

 // Either of the following two patterns can be used to immediately invoke
   // a function expression, utilizing the function's execution context to
   // create "privacy."
   //可以使用以下两种模式中的任何一种立即调用函数表达式，利用函数的执行上下文来创建“privacy”。

   (function(){ /* code */ }()); // Crockford recommends this one // Crockford建议这一个
   (function(){ /* code */ })(); // But this one works just as well //但是这个也同样有效

   // Because the point of the parens or coercing operators is to disambiguate
   // between function expressions and function declarations, they can be
   // omitted when the parser already expects an expression (but please see the
   // "important note" below).
   // 因为parens或强制操作符的目的是消除函数表达式和函数声明之间的歧义，当解析器已经获得期望的表达式时，可以省略它们(但是请参阅下面的“重要提示”)。

   var i = function(){ return 10; }();
   true && function(){ /* code */ }();
   0, function(){ /* code */ }();

   // If you don't care about the return value, or the possibility of making
   // your code slightly harder to read, you can save a byte by just prefixing
   // the function with a unary operator.
   //如果你不关心返回值，或者让你的代码稍微难以阅读，那么你可以通过在一元运算符前添加前缀来保存一个字节。

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

   // Here's another variation, from @kuvos - I'm not sure of the performance
   // implications, if any, of using the `new` keyword, but it works.
   // http://twitter.com/kuvos/status/18209252090847232
   //以下是另一个变体，来自@kuvos--我不确定使用`new`关键字的性能影响（如果有的话），但它有效。http://twitter.com/kuvos/status/18209252090847232

   new function(){ /* code */ }
   new function(){ /* code */ }() // Only need parens if passing arguments40                                 // 如果传递参数只需要parens

 // This doesn't work like you might think, because the value of `i` never
   // gets locked in. Instead, every link, when clicked (well after the loop
   // has finished executing), alerts the total number of elements, because
   // that's what the value of `i` actually is at that point.
   //这不会像你想象的那样工作，因为`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' );

   }

   // This works, because inside the IIFE, the value of `i` is locked in as
   // `lockedInIndex`. After the loop has finished executing, even though the
   // value of `i` is the total number of elements, inside the IIFE the value
   // of `lockedInIndex` is whatever the value passed into it (`i`) was when
   // the function expression was invoked, so when a link is clicked, the
   // correct value is alerted.
   // 这是有效的，因为在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 );

   }

   // You could also use an IIFE like this, encompassing (and returning) only
   // the click handler function, and not the entire `addEventListener`
   // assignment. Either way, while both examples lock in the value using an
   // IIFE, I find the previous example to be more readable.
  //您也可以像这样使用IIFE，仅包含（并返回）click处理函数，而不是整个`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' );

   }

   // This is a self-executing function. It's a function that executes (or
   // invokes) itself, recursively:
   // 这是一个自我执行的功能。 这是一个递归执行（或调用）自身的函数：

   function foo() { foo(); }

   // This is a self-executing anonymous function. Because it has no
   // identifier, it must use the  the `arguments.callee` property (which
   // specifies the currently executing function) to execute itself.
   //这是一个自我执行的匿名函数。 因为它没有标识符，所以它必须使用`arguments.callee`属性（它指定当前正在执行的函数）来执行它自己。

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

   // This *might* be a self-executing anonymous function, but only while the
   // `foo` identifier actually references it. If you were to change `foo` to
   // something else, you'd have a "used-to-self-execute" anonymous function.
   //这'可能'是一个自我执行的匿名函数，但只有在`foo`标识符实际引用它时。 如果你想把`foo`改成别的东西，你会有一个“二手自行执行”的匿名函数。

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

   // Some people call this a "self-executing anonymous function" even though
   // it's not self-executing, because it doesn't invoke itself. It is
   // immediately invoked, however.
   // 有些人称之为“自我执行的匿名函数”，即使它不是自动执行的，因为它不会自行调用。 然而，它立即被调用。

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

   // Adding an identifier to a function expression (thus creating a named
   // function expression) can be extremely helpful when debugging. Once named,
   // however, the function is no longer anonymous.

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

   // IIFEs can also be self-executing, although this is, perhaps, not the most
   // useful pattern.
   // IIFE也可以自我执行，尽管这也许不是最有用的模式。

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

   // One last thing to note: this will cause an error in BlackBerry 5, because
   // inside a named function expression, that name is undefined. Awesome, huh?
   // 最后要注意的是：这会导致BlackBerry 5出现错误，因为在命名函数表达式中，该名称是未定义的。 真棒，嗯？

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

 // Create an anonymous function expression that gets invoked immediately,
   // and assign its *return value* to a variable. This approach "cuts out the
   // middleman" of the named `makeWhatever` function reference.
   //
   // As explained in the above "important note," even though parens are not
   // required around this function expression, they should still be used as a
   // matter of convention to help clarify that the variable is being set to
   // the function's *result* and not the function itself.

   //创建一个立即被调用的匿名函数表达式，并将其*返回值*赋给一个变量。 这种方法“切断了名为`makeWhatever`（译者注：这个并不存在于上下文）函数引用的中间人"。

   //正如上面“重要说明”中所解释的，尽管在这个函数表达式周围不需要使用parens，但仍然应该将它们作为约定使用，以帮助阐明变量被设置为函数的*result*，而不是函数本身。

   var counter = (function(){
     var i = 0;

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

   // `counter` is an object with properties, which in this case happen to be
   // methods.
   // ' counter '是一个具有属性的对象，在本例中正好是方法。

   counter.get();
   counter.set( 3 );
   counter.increment();
   counter.increment(); 

   counter.i; // undefined (`i` is not a property of the returned object)
             //undefined（`i`不是返回对象的属性）

   i; // ReferenceError: i is not defined (it only exists inside the closure)44      // ReferenceError:没有定义i(它只存在于闭包内)