http://robertnyman.com/2008/10/09/explaining-javascript-scope-and-closures/
Explaining JavaScript scope and closures
I thought I’d try to explain something which many people struggle with: JavaScript scope and closures.
Background
There are a number of articles and blog posts out there trying to explain scope and closures, but overall I’d say that a majority of them aren’t crystal-clear. Besides, a number of them take for granted that everyone has developed in about 15 other languages before, while my experience is that a lot of people writing JavaScript come from a HTML and CSS background, instead of C and Java.
Therefore, my humble goal with this article is for everyone to finally grasp what scope and closures are, how they works, and especially how you can benefit from them. You do need to understand the basic concepts of variables and functions before reading this.
Scope
Scope refers to where variables and functions are accessible, and in what context it is being executed. Basically, a variable or function can be defined in a global or local scope. Variables have so-called function scope, and functions have the same scope as variables.
Global scope
When something is global means that it is accessible from anywhere in your code. Take this for example:
1.
var
monkey =
"Gorilla"
;
2.
3.
function
greetVisitor () {
4.
return
alert(
"Hello dear blog reader!"
);
5.
}
If that code was being run in a web browser, the function scope would be window, thus making it available to everything running in that web browser window.
Local scope
As opposed to the global scope, the local scope is when something is just defined and accessible in a certain part of the code, like a function. For instance;
1.
function
talkDirty () {
2.
var
saying =
"Oh, you little VB lover, you"
;
3.
return
alert(saying);
4.
}
5.
alert(saying);
// Throws an error
If you take a look at the code above, the variable saying is only available within the talkDirty function. Outside of it it isn’t defined at all. Note of caution: if you were to declare saying without the var keyword preceding it, it would automatically become a global variable.
What this also means is that if you have nested functions, the inner function will have access to the containing functions variables and functions:
1.
function
saveName (firstName) {
2.
function
capitalizeName () {
3.
return
firstName.toUpperCase();
4.
}
5.
var
capitalized = capitalizeName();
6.
return
capitalized;
7.
}
8.
alert(saveName(
"Robert"
));
// Returns "ROBERT"
As you just saw, the inner function capitalizeName didn’t need any parameter sent in, but had complete access to the parameter firstName in the outer saveName function. For clarity, let’s take another example:
01.
function
siblings () {
02.
var
siblings = [
"John"
,
"Liza"
,
"Peter"
];
03.
function
siblingCount () {
04.
var
siblingsLength = siblings.length;
05.
return
siblingsLength;
06.
}
07.
function
joinSiblingNames () {
08.
return
"I have "
+ siblingCount() +
" siblings:\n\n"
+ siblings.join(
"\n"
);
09.
}
10.
return
joinSiblingNames();
11.
}
12.
alert(siblings());
// Outputs "I have 3 siblings: John Liza Peter"
As you just saw, both inner functions have access to the siblings array in the containing function, and each inner function have access to the other inner functions on the same level (in this case, joinSiblingNames can access siblingCount). However, the variable siblingsLength in the siblingCount is only available within that function, i.e. that scope.
Closures
Now when you hopefully have gotten a better grasp of what scope is, let’s add closures to the mix. Closures are expressions, usually functions, which can work with variables set within a certain context. Or, to try and make it easier, inner functions referring to local variables of its outer function create closures. For instance:
1.
function
add (x) {
2.
return
function
(y) {
3.
return
x + y;
4.
};
5.
}
6.
var
add5 = add(5);
7.
var
no8 = add5(3);
8.
alert(no8);
// Returns 8
Whoa, whoa! What just happened? Let’s break it down:
- When the add function is called, it returns a function.
- That function closes the context and remembers what the parameter x was at exactly that time (i.e. 5 in the code above)
- When the result of calling the add function is assigned to the variable add5, it will always know what x was when it was initially created.
- The add5 variable above refers to a function which will always add the value 5 to what is being sent in.
- That means when add5 is called with a value of 3, it will add 5 together with 3, and return 8.
So, in the world of JavaScript, the add5 function actually looks like this in reality:
1.
function
add5 (y) {
2.
return
5 + y;
3.
}
The infamous loop problem
How many times have you created some sort of loop where you wanted to assign the value of i in some way, e.g. to an element, and found out it just returned the last value i had?
Incorrect reference
Let’s take a look at this faulty code, which creates 5 a elements, adds the value of i as a text to each element and an onclick which is expected to alert the value of i for that link, i.e. the same value as in the a element’s text. It then appends them to your document body:
01.
function
addLinks () {
02.
for
(
var
i=0, link; i<5; i++) {
03.
link = document.createElement(
"a"
);
04.
link.innerHTML =
"Link "
+ i;
05.
link.onclick =
function
() {
06.
alert(i);
07.
};
08.
document.body.appendChild(link);
09.
}
10.
}
11.
window.onload = addLinks;
Each a element gets the correct text, i.e. “Link 0″, “Link 1″ and so on. But whichever link you click, it alerts the number “5″. Oh my God, why? The reason for this is that the variable i get its value increased with 1 for each iteration of the loop, and since the onclick event isn’t being executed, just applied to the a element, it adds up.
Therefore, the loop continues until i is 5, which is the last value of i before the function addLinks exits. Then, whenever the onclick event is actually being triggered, it takes the last value of i.
Working reference
What you want to do instead is create a closure, so that when you apply the value of i to the onclick event of the a element, it gets the exact value of i at just that moment in time. Like this:
01.
function
addLinks () {
02.
for
(
var
i=0, link; i<5; i++) {
03.
link = document.createElement(
"a"
);
04.
link.innerHTML =
"Link "
+ i;
05.
link.onclick =
function
(num) {
06.
return
function
() {
07.
alert(num);
08.
};
09.
}(i);
10.
document.body.appendChild(link);
11.
}
12.
}
13.
window.onload = addLinks;
With this code, if you click the first a element it will alert “0″, the second “1″ etc; just what you probably expected with the first code I showed you to do. The solution here is that the inner function of what’s applied to the onclick event create a closure where it references the parameter num, i.e. what the i variable is at just that time.
That function then closes with that value safely tucked away, and can then return its corresponding number when the onclick event is being called.
Self-invoking functions
Self-invoking functions are functions who execute immediately, and create their own closure. Take a look at this:
1.
(
function
() {
2.
var
dog =
"German Shepherd"
;
3.
alert(dog);
4.
})();
5.
alert(dog);
// Returns undefined
Ok, so the dog variable was only available within that context. Big deal, man, hidden dogs… But, my friends, this is where it becomes really interesting! It solved our problem with the loop above, and it is also the base for the Yahoo JavaScript Module Pattern.
Yahoo JavaScript Module Pattern
The gist of the pattern is that it uses a self-invoking function to create a closure, hence making it possible to have private and public properties and methods. A simple example:
01.
var
person =
function
() {
02.
// Private
03.
var
name =
"Robert"
;
04.
return
{
05.
getName :
function
() {
06.
return
name;
07.
},
08.
setName :
function
(newName) {
09.
name = newName;
10.
}
11.
};
12.
}();
13.
alert(person.name);
// Undefined
14.
alert(person.getName());
// "Robert"
15.
person.setName(
"Robert Nyman"
);
16.
alert(person.getName());
// "Robert Nyman"
The beauty of this is that you now can decide on your own what will be publicly visible for your object (and can be overwritten), and what is private and no one can access nor alter. The variable name above is hidden outside the context of the function, but accessible from the returned getName respectively setName functions, since they create closures where they have a reference to the name variable.
Conclusion
My sincere hope is that after reading this, novice or experienced programmer, you have gotten a clear view of how scope and closures actually work in JavaScript. Questions and feedback are very welcome, and if any input is deemed important enough, I will update this article with it.
Happy coding!