What is the exact use of closures in Javascript?

Question

Hi still i'm not sure about the exact usage of using closures in javascript.I have idea about closures "A closure is an inner function that has access to the outer (enclosing) function’s variables—scope chain".But i don't know why we are using closures in javascript.

Answer 1

It is because of information hiding.

var myModule = (function (){

    var privateClass = function (){};
    privateClass.prototype = {
        help: function (){}
    };

    var publicClass = function (){
        this._helper = new privateClass();
    };
    publicClass.prototype = {
        doSomething: function (){
            this._helper.help();
        }
    };

    return {
        publicClass: publicClass
    };

})();

var instance = new myModule.publicClass();
instance.doSomething();

In javascript you don't have classes with ppp (public, protected, private) properties so you have to use closures to hide the information. On class level that would be very expensive, so the only thing you can do for better code quality to use closure on module level, and use private helper classes in that closure. So closure is for information hiding. It is not cheap, it cost resources (memory, cpu, etc..) so you have to use closures just in the proper places. So never use it on class level for information hiding, because it is too expensive for that.

Another usage to bind methods to instances by using callbacks.

Function.prototype.bind = function (context){
    var callback = this;
    return function (){
        return callback.apply(context, arguments);
    };
};

Typical usage of bound function is by asynchronous calls: defer, ajax, event listeners, etc...

var myClass = function (){
    this.x = 10;
};
myClass.prototype.displayX = function (){
    alert(this.x);
};

var instance = new myClass();
setTimeout(instance.displayX.bind(instance), 1000); //alerts "x" after 1 sec

Answer 2

It allows you to succinctly express logic without needing to repeat yourself or supply a large number of parameters and arguments for a callback function.

There is more information available here: javascript closure advantages?

Answer 3

In general, the main use of closures is to create a function that captures the state from it's context. Consider that the function has the captured variables but they are not passed as parameters.

So, you can think of it of a way to create families of functions. For example if you need a series of function that only differ in one value, but you cannot pass that value as a parameter, you can create them with closures.

The Mozilla Developer Network has a good introduction to closures. It shows the following example:

function init() {
  var name = "Mozilla";
  function displayName() {
    alert(name);
  }
  displayName();
}
init();

In this case the function displayName has captured the variable name. As it stand this example is not very useful, but you can consider the case where you return the function:

function makeFunc() {
  var name = "Mozilla";
  function displayName() {
    alert(name);
  }
  return displayName;
}

var myFunc = makeFunc();
myFunc();

Here the function makeFunc return the function displayName that has captured the variable name. Now that function can be called outside by assigning it to the variable myFunc.

To continue with this example consider now if the captured variable name were actually a parameter:

function makeFunc(name) {
  function displayName() {
    alert(name);
  }
  return displayName;
}

var myFunc = makeFunc("Mozilla");
myFunc();

Here you can see that makeFunc create a function that shows a message with the text passed as parameter. So it can create a whole family of function that vary only on the value of that variable ("Mozilla" in the example). Using this function we can show the message multiple times.

What is relevant here is that the value that will be shown in the massage has been encapsulated. We are protecting this value in a similar fashion a private field of a class hides a value in other languages.

This allows you to, for example, create a function that counts up:

function makeFunc(value) {
  function displayName() {
    alert(value);
    value++;
  }
  return displayName;
}

var myFunc = makeFunc(0);
myFunc();

In this case, each time you call the function that is stored in myFunc you will get the next number, first 0, next 1, 2... and so on.

---

A more advanced example is the "Counter" "class" also from the Mozilla Developer Network. It demonstrates the module pattern:

var Counter = (function() {
  var privateCounter = 0;
  function changeBy(val) {
    privateCounter += val;
  }
  return {
    increment: function() {
      changeBy(1);
    },
    decrement: function() {
      changeBy(-1);
    },
    value: function() {
      return privateCounter;
    }
  }   
})();

alert(Counter.value()); /* Alerts 0 */
Counter.increment();
Counter.increment();
alert(Counter.value()); /* Alerts 2 */
Counter.decrement();
alert(Counter.value()); /* Alerts 1 */

Here you can see that Counter is an object that has a method increment that advances the privateCounter variable, and the method decrement that decrements it. It is possible to query the value of this variable by calling the method value.

The way this is archived is with an auto-invocation of an anonymous function that creates a hidden scope where the varialbe privateCounter is declared. Now this variable will only be accessible from the functions that capture its value.

Answer 4

Imagine if instead of

   alert("Two plus one equals" + (2+1) );

you'd be forced to declare a variable for every constant you ever use.

   var Two = 2;
   var One = 1;
   var myString = "Two plus one equals";
   alert(myAlert + (Two + One) );

You'd go crazy if you had to define a variable for every single constant before you can ever use it.

The access to local variables in case of closures is an advantage, but the primary role - usefulness - is the use of a function as a primary expression, a constant.

Take

  function Div1OnClick()
  {
       Counter.clickCount ++; 
  }

  $('#Div1').click(Div1OnClick);

versus

  $('#Div1').click(function(){ Counter.clickCount++; });

You don't create a new function name in the "above" namespace just to use it once. The actual activity is right there where it's used - you don't need to chase it across the code to where it was written. You can use the actual function as a constant instead of first defining and naming it and then calling it by name, and while there are countless caveats, advantages and tricks connected to closures, that's the one property that sells them.

Answer 5

Closures are a powerful construct used to implement a lot of additional features in JavaScript. For instance a closure can be used to expose private state as follows:

function getCounter() {
    var count = 0;

    return function () {
        return ++count;
    };
}

var counter = getCounter();

alert(counter()); // 1
alert(counter()); // 2
alert(counter()); // 3

In the above example when we call getCounter we create a private variable count. Then we return a function which return count incremented. Hence the function we return is a closure in the sense that it closes over the variable count and allows you to access it even after count goes out of scope.

That's a lot of information stuffed in a few lines. Let's break it down?

Okay, so variables have a lifetime just like people do. They are born, they live and they die. The beginning scope marks the birth of a variable and the end of a scope marks the death of a variable.

JavaScript only has function scopes. Hence when you declare a variable inside a function it's hoisted to the beginning of the function (where it's born).

When you try to access a variable which is not declared you get a ReferenceError. However when you try to access a variable which is declared later on you get undefined. This is because declarations in JavaScript are hoisted.

function undeclared_variable() {
    alert(x);
}

undeclared_variable();

When you try to access an undeclared variable you get a ReferenceError.

function undefined_variable() {
    alert(x);

    var x = "Hello World!";
}

undefined_variable();

When you try to access a variable which is declared later in the function you get undefined because only the declaration is hoisted. The definition comes later.

---

Coming back to scopes a variable dies when it goes out of scope (usually when the function within which the variable is declared ends).

For example the following program will give a ReferenceError because x is not declared in the global scope.

function helloworld() {
    var x = "Hello World!";
}

helloworld();

alert(x);

Closures are interesting because they allow you to access a variable even when the function within which variable is declared ends. For example:

function getCounter() {
    var count = 0;

    return function () {
        return ++count;
    };
}

var counter = getCounter();

alert(counter()); // 1
alert(counter()); // 2
alert(counter()); // 3

In the above program the variable count is defined in the function getCounter. Hence when a call to getCounter ends the variable count should die as well.

However it doesn't. This is because getCounter returns a function which accesses count. Hence as long as that function (counter) is alive the variable count will stay alive too.

In this case the function which is returned (counter) is called a closure because it closes over the variable count which is called the upvalue of counter.

Uses

Enough with the explanation. Why do we need closures anyway?

As I already mentioned before the main use of closures is to expose private state as is the case with the getCounter function.

Another common use case of closures is partial application. For instance:

function applyRight(func) {
    var args = Array.prototype.slice.call(arguments, 1);

    return function () {
        var rest = Array.prototype.slice.call(arguments);
        return func.apply(this, rest.concat(args));
    };
}

function subtract(a, b) {
    return a - b;
}

var decrement = applyRight(subtract, 1);

alert(decrement(1)); // 0

In the above program we had a function called subtract. We used partial application to create another function called decrement from this subtract function.

As you can see the decrement function is actually a closure which closes over the variables func and args.

That's pretty much all you need to know about closures.