What is the (function() { } )() construct in JavaScript?

What is the (function() { } )() construct in JavaScript?

I used to know what this meant, but I’m struggling now…
Is this basically saying document.onload?
(function () {

})();

Solutions/Answers:

Solution 1:

It’s an Immediately-Invoked Function Expression, or IIFE for short. It executes immediately after it’s created.

It has nothing to do with any event-handler for any events (such as document.onload).
Consider the part within the first pair of parentheses: (function(){})();….it is a regular function expression. Then look at the last pair (function(){})();, this is normally added to an expression to call a function; in this case, our prior expression.

This pattern is often used when trying to avoid polluting the global namespace, because all the variables used inside the IIFE (like in any other normal function) are not visible outside its scope.
This is why, maybe, you confused this construction with an event-handler for window.onload, because it’s often used as this:

(function(){
    // all your code here
    var foo = function() {};
    window.onload = foo;
    // ...
})();
// foo is unreachable here (it’s undefined)

Correction suggested by Guffa:

The function is executed right after it’s created, not after it is parsed. The entire script block is parsed before any code in it is executed. Also, parsing code doesn’t automatically mean that it’s executed, if for example the IIFE is inside a function then it won’t be executed until the function is called.

Update
Since this is a pretty popular topic, it’s worth mentioning that IIFE’s can also be written with ES6’s arrow function (like Gajus has pointed out in a comment) :

((foo) => foo)('foo value')

Solution 2:

It’s just an anonymous function that is executed right after it’s created.

It’s just as if you assigned it to a variable, and used it right after, only without the variable:

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

In jQuery there is a similar construct that you might be thinking of:

$(function(){
});

That is the short form of binding the ready event:

$(document).ready(function(){
});

Solution 3:

An immediately-invoked function expression (IIFE) immediately calls a function. This simply means that the function is executed immediately after the completion of the definition.

Three more common wordings:

// Crockford's preference - parens on the inside
(function() {
  console.log('Welcome to the Internet. Please follow me.');
}());

//The OPs example, parentheses on the outside
(function() {
  console.log('Welcome to the Internet. Please follow me.');
})();

//Using the exclamation mark operator
//https://stackoverflow.com/a/5654929/1175496
!function() {
  console.log('Welcome to the Internet. Please follow me.');
}();

If there are no special requirements for its return value, then we can write:

!function(){}();  // => true
~function(){}(); // => -1
+function(){}(); // => NaN
-function(){}();  // => NaN

Alternatively, it can be:

~(function(){})();
void function(){}();
true && function(){ /* code */ }();
15.0, function(){ /* code */ }();

You can even write:

new function(){ /* code */ }
31.new function(){ /* code */ }() //If no parameters, the last () is not required

Solution 4:

It declares an anonymous function, then calls it:

(function (local_arg) {
   // anonymous function
   console.log(local_arg);
})(arg);

Solution 5:

That is saying execute immediately.

so if I do:

var val = (function(){
     var a = 0;  // in the scope of this function
     return function(x){
         a += x;
         return a;
     };
})();

alert(val(10)); //10
alert(val(11)); //21

Fiddle: http://jsfiddle.net/maniator/LqvpQ/


Second Example:

var val = (function(){
     return 13 + 5;
})();

alert(val); //18

Solution 6:

That construct is called Immediately Invoked Function Expression (IIFE) which means it gets executed immediately. Think of it as a function getting called automatically when the interpreter reaches that function.

Most Common Use-case:

One of its most common use case is to limit the scope of a variable made via var. Variables created via var have a scope limited to a function so this construct (which is a function wrapper around certain code) will make sure that your variable scope doesn’t leak out of that function.

In following example, count will not be available outside the immediately invoked function i.e. Scope of count will not leak out of the function. You should get a Reference Error, should you try to access it outside of the immediately invoked function anyway.

(function () { 
    var count = 10;
})();
console.log(count);  // Reference Error: count is not defined

ES6 Alternative (Recommended)

In ES6, we now can have variables created via let and const. Both of them are block-scoped (unlike var which is a function-scoped).

Therefore, instead of using that complex construct of IIFE for the use case I mentioned above, you can now write much, much simpler code to make sure that a variable’s scope does not leak out of your desired block.

{ 
    let count = 10;
};
console.log(count);  // Reference Error: count is not defined

In this example, we used let to define a count variable which makes count limited to the block of code, we created with the curly brackets {...}.

I call it a Curly Jail.