Mastering JavaScript

Functions, Closures, and Modules
Later in this book, we will look at several functional tricks such as memoization
and caching function calls. If you have reached here by quickly reading through the
entire chapter, I would suggest that you stop for a while and contemplate on what
we have discussed so far. The last few pages contain a ton of information and it will
take some time for all this information to sink in. I would suggest that you reread
this chapter before proceeding further. The next section will focus on closures and
the module pattern.
Closures
Traditionally, closures have been a feature of purely functional programming
languages. JavaScript shows its affinity with such functional programming
languages by considering closures integral to the core language constructs. Closures
are gaining popularity in mainstream JavaScript libraries and advanced production
code because they let you simplify complex operations. You will hear experienced
JavaScript programmers talking almost reverently about closures—as if they are
some magical construct far beyond the reach of the intellect that common men
possess. However, this is not so. When you study this concept, you will find closures
to be very obvious, almost matter-of-fact. Till you reach closure enlightenment, I
suggest you read and reread this chapter, research on the Internet, write code, and
read JavaScript libraries to understand how closures behave—but do not give up.
The first realization that you must have is that closure is everywhere in JavaScript. It
is not a hidden special part of the language.
Before we jump into the nitty-gritty, let's quickly refresh the lexical scope in
JavaScript. We discussed in great detail how lexical scope is determined at the
function level in JavaScript. Lexical scope essentially determines where and how all
identifiers are declared and predicts how they will be looked up during execution.
In a nutshell, closure is the scope created when a function is declared that allows the
function to access and manipulate variables that are external to this function. In other
words, closures allow a function to access all the variables, as well as other functions,
that are in scope when the function itself is declared.
Let's look at some example code to understand this definition:
var outer = 'I am outer'; //Define a value in global scope
function outerFn() { //Declare a a function in global scope
console.log(outer);
}
outerFn(); //prints - I am outer
[ 66 ]
www.it-ebooks.info