3 Answers
3

Look at a normal function definition that you want to call once and only once:

function add(x,y) {
var z = x + y;
// do something with z
}
add(2,3);

You could reduce this code so that you execute it straight away, there is no need to name it add:

(function(x ,y) {
var z = x + y;
// do something with z
})(2,3)

Note how we have surrounded the function with a set of parenthesis to make it a callable expression. This pattern is often used to create a closure (capture the state of) certain variables, for example:

jQuery.noConflict(); //Disables the use of $ in the global scope
(function($) {
//Safely use $ inside this function
$('.link').click(function(e) {
//etc
});
})(jQuery);

As RobG pointed out, this is the only valid statement choice in your original question.

(function (){
// some code
}())

This is executed right after it is parsed, and provides a way to out-scope the code inside the function from the rest of your code. This is called a closure (see Closures on MDN) and may help with memory leaks in your scripts.

Enclosing the code in a grouping operator changes it from a function declaration to a function expression (where the name is optional and usually omitted). That pattern is often called an "immediately invoked function expression" (iife) or "immediately executed function expression" (iefe).

It is used to replace a function declaration that is called just once. It is also fundamental to the module pattern.