Immediately-invoked function expression

An immediately-invoked function expression (or IIFE, pronounced "iffy"^[1]) is a JavaScript design pattern which produces a lexical scope using JavaScript's function scoping. Immediately-invoked function expressions can be used to avoid variable hoisting from within blocks, protect against polluting the global environment and simultaneously allow public access to methods while retaining privacy for variables defined within the function. This pattern has been referred to as a self-executing anonymous function,^[2] but Ben Alman introduced the term IIFE as a more semantically accurate term for the pattern, shortly after its discussion arose on comp.lang.javascript.^{[1][3] [4]}

Usage

Immediately-invoked function expressions may be written in a number of different ways,^[5] although a common convention is to enclose both the function expression and invocation in parentheses.^[6][7]

(function() {
  // the code here is executed once in its own scope
}());

Passing variables into the scope is done as follows:

(function(a, b) {
  // a == 'hello'
  // b == 'world'
}('hello', 'world'));

An initial parenthesis is one case where the automatic semicolon insertion (ASI) in JavaScript can cause problems and being interpreted as a call to the last term on the preceding line, so semicolons are necessary to avoid this. In some styles that omit optional semicolons, the semicolon is placed in front of the parenthesis, and is known as a defensive semicolon.^[8][9] For example:

a = b + c
;(function() {
  // code 
}());

...to avoid being parsed as c(...).

Examples

The key to understanding design patterns such as immediately-invoked function expressions is to realize JavaScript has function scope (but not block scope) and passes values by reference inside a closure.^[10]

Evaluation context

A lack of block scope means that variables defined inside, for example, a for loop will have their definition "hoisted" to the top of the enclosing function. Evaluating a function which depends on variables modified by the outer function (including by iteration) can be difficult. We can see this without a loop if we update a value between defining and invoking the function.^[11]

var v, getValue;
v = 1;
getValue = function() { return v; };
v = 2;
 
getValue(); // 2

While the result may seem obvious when updating v manually, it can produce unintended results when getValue() is defined inside a loop.

var v, getValue;
v = 1;
getValue = (function(x) {
  return function() { return x; };
}(v));
v = 2;
 
getValue(); // 1

Here the function passes v as an argument and is invoked immediately, preserving the inner function's execution context.^[12]

David Herman's Effective JavaScript contains an example illustrating the problems of evaluation context inside loops.^[13] While Herman's example is deliberately convoluted it arises directly from the same lack of block scope.^[14]

Establishing private variables and accessors

IIFEs are also useful for establishing private methods for accessible functions while still exposing some properties for later use.^[15] The following example comes from Alman's post on IIFEs.^[1]

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(); // 0
counter.set( 3 );
counter.increment(); // 4
counter.increment(); // 5

If we attempt to access counter.i from the global environment, it will be undefined as it is enclosed within the invoked function and is not a property of counter. Likewise, if we attempt to access i it will result in an error as we have not declared i in the global environment.

Terminology

"Immediately-invoked function expression" as a term describes a design pattern which has also been referred to as a "self-executing anonymous function."^[1][5] However, immediately-invoked functions need not be anonymous and ECMAScript 5's strict mode forbids arguments.callee,^[16] making the latter term less accurate.^[3][12]

References

External links

• "Functions and function scope". Mozilla JavaScript Reference. Mozilla Developer Network. Retrieved 4 February 2013. 
• Soshnikov, Dmitry. "ECMA-262-3 in detail. Chapter 5. Functions.". Retrieved 4 February 2013.