In a nutshell Javascript Closures allow a function to access a variable that is declared in a lexical-parent function.

Let's see a more detailed explanation. To understand closures it is important to understand how JavaScript scopes variables.

Scopes

In JavaScript scopes are defined with functions. Every function defines a new scope.

Consider the following example;

function f() {//begin of scope f var foo='hello'; //foo is declared in scope f for(var i=0;i<2;i++){//i is declared in scope f //the for loop is not a function, therefore we are still in scope f var bar = 'Am I accessible?';//bar is declared in scope f console.log(foo); } console.log(i); console.log(bar); }//end of scope f

calling f prints

hello hello 2 Am I Accessible?

Let's now consider the case we have a function g defined within another function f .

function f() {//begin of scope f function g() {//being of scope g /*...*/ }//end of scope g /*...*/ }//end of scope f

We will call f the lexical parent of g . As explained before we now have 2 scopes; the scope f and the scope g .

But one scope is "within" the other scope, so is the scope of the child function part of the scope of the parent function? What happens with the variables declared in the scope of the parent function; will I be able to access them from the scope of the child function? That's exactly where closures step in.

Closures

In JavaScript the function g can not only access any variables declared in scope g but also access any variables declared in the scope of the parent function f .

Consider following;

function f()//lexical parent function {//begin of scope f var foo='hello'; //foo declared in scope f function g() {//being of scope g var bar='bla'; //bar declared in scope g console.log(foo); }//end of scope g g(); console.log(bar); }//end of scope f

calling f prints

hello undefined

Let's look at the line console.log(foo); . At this point we are in scope g and we try to access the variable foo that is declared in scope f . But as stated before we can access any variable declared in a lexical parent function which is the case here; g is the lexical parent of f . Therefore hello is printed.

Let's now look at the line console.log(bar); . At this point we are in scope f and we try to access the variable bar that is declared in scope g . bar is not declared in the current scope and the function g is not the parent of f , therefore bar is undefined



Actually we can also access the variables declared in the scope of a lexical "grand parent" function. Therefore if there would be a function h defined within the function g

function f() {//begin of scope f function g() {//being of scope g function h() {//being of scope h /*...*/ }//end of scope h /*...*/ }//end of scope g /*...*/ }//end of scope f

then h would be able to access all the variables declared in the scope of function h , g , and f . This is done with closures. In JavaScript closures allows us to access any variable declared in the lexical parent function, in the lexical grand parent function, in the lexical grand-grand parent function, etc. This can be seen as a scope chain; scope of current function -> scope of lexical parent function -> scope of lexical grand parent function -> ... until the last parent function that has no lexical parent.

The window object

Actually the chain doesn't stop at the last parent function. There is one more special scope; the global scope. Every variable not declared in a function is considered to be declared in the global scope. The global scope has two specialities;

every variable declared in the global scope is accessible everywhere

the variables declared in the global scope correspond to the properties of the window object.

Therefore there are exactly two ways of declaring a variable foo in the global scope; either by not declaring it in a function or by setting the property foo of the window object.

Both attempts uses closures

Now that you have read a more detailed explanation it may now be apparent that both solutions uses closures. But to be sure, let's make a proof.

Let's create a new Programming Language; JavaScript-No-Closure. As the name suggests, JavaScript-No-Closure is identical to JavaScript except it doesn't support Closures.

In other words;

var foo = 'hello'; function f(){console.log(foo)}; f(); //JavaScript-No-Closure prints undefined //JavaSript prints hello

Alright, let's see what happens with the first solution with JavaScript-No-Closure;

for(var i = 0; i < 10; i++) { (function(){ var i2 = i; setTimeout(function(){ console.log(i2); //i2 is undefined in JavaScript-No-Closure }, 1000) })(); }

therefore this will print undefined 10 times in JavaScript-No-Closure.

Hence the first solution uses closure.

Let's look at the second solution;

for(var i = 0; i < 10; i++) { setTimeout((function(i2){ return function() { console.log(i2); //i2 is undefined in JavaScript-No-Closure } })(i), 1000); }

therefore this will print undefined 10 times in JavaScript-No-Closure.

Both solutions uses closures.