以防你没有注意到，我先声明下：我总是要求术语。所以，在听到许多次 流行的，但是让人误解的 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/
转载请注明出处
