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."(function(){ /* code */ }()); // Crockford recommends this one(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).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/18209252090847232new function(){ /* code */ }new function(){ /* code */ }() // Only need parens if passing arguments

// 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.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.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.(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?(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.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.get(); // 0counter.set( 3 );counter.increment(); // 4counter.increment(); // 5counter.i; // undefined (`i` is not a property of the returned object)i; // ReferenceError: i is not defined (it only exists inside the closure)