Javascript explain this code please

I see开发者_运维问答 in a lot of scripts this pattern

(function(){})();

What is it and why use it?

It's used to force the creation of a local scope it avoid poluting the current (often global) scope with the declarations.

It could be rewritten like this if you want to avoid the anonymous function :

var scope = function() { /*...*/ };
scope();

But the anonymous function syntax have the advantage that the parent or global scope isn't even poluted by the name of the function.

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

It's also a good way to implement information hiding in javascript as declarations (functions and variables) in this scope won't be visible from the outside. But they could still see each other and as javascript implement closures functions declared inside such a scope will have access to other declarations in the same scope.

That is defining a function with no name, and immediately calling it. Because Javascript functions act as closures -- a persistent scope -- this is a useful way to create a set of interconnected objects or functions.

An anonymous function is a function (or a subroutine) defined, and possibly called, without being bound to an identifier.

This is the basic syntax for creating a closure. More typically, it'd contain some code:

(function(){
    //Your Code Here
})();

This is equivalent to

var some_function = function() {
    //Your Code Here
};
some_function();

The biggest reason for doing this is cleanliness; any variables declared outside of any function are global; however, variables declared inside of this function are contained inside of this function and won't affect or interactive with any code outside of the function. It's good practice to wrap any kind of reusable plugin in a closure.

It's immediately executing anonymous function. It's basically the same as:

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

but does not require usage of additional variable. you need to wrap it in additional parenthesis to get the function as a result of your expression - otherwise it's understood as function declaration, and you can't execute a declaration.

it's mostly used for scope protection - because JS has functional scope, every variable defined as var x; inside such function will be kept in it's function local scope.

all of this simply means 'immediately execute everything inside this function without polluting the global scope'.

it's also commonly used in well known patterns, such as module pattern and revealing module pattern. please see http://www.adequatelygood.com/2010/3/JavaScript-Module-Pattern-In-Depth for more detail.

It is called an immediate function or an anonymous closure and is the basis of the module pattern.

It is used to create a private local scope for code.