javascript

CHAPTER 6 ■ FUNCTIONS AND ARRAYS
218
Let’s get to the JavaScript to see what we can do with all this information. First, some background:
any variable that you declare within the curly braces wrapping the block of an if, for, while, or other
compound statement is visible outside the block, as you have seen throughout this book. Put another
way, curly braces do not provide a way to create private variables.
In contrast, functions have function scope, which means that any variables or functions declared
within the curly braces wrapping a function block normally are not visible outside of the block. Let’s find
out why.
Whenever you define a function, JavaScript saves the scope chain as part of the new function object;
that is to say, the scope chain is the sequence of objects, beginning with the function’s own call object
and ending with the global window object. This means this part of the scope chain is set in stone before
the function ever runs. However, any variables, functions, or arguments contained by the call and global
objects comprising that scope chain are live.
Then, when you invoke a function, JavaScript adds any variables defined locally within the function,
named parameters, the arguments object, and this to the scope chain. So these variable objects will
differ every time you invoke the function. JavaScript looks in this complete set of items in the scope
chain when it is looking up the value of a variable. In other words, when you invoke a function that uses
a variable, JavaScript can only use the variable if it is declared in the scope chain.
Normally, after an invoked function returns, everything added to the scope chain when you invoked
the function is destroyed. However, if you create a closure, the objects contained in function scope are
not destroyed. Therefore, you may query the named parameters and locally defined variables for that
invocation even after it has ended. Let’s look at closures now.
Insofar as closure is a wildly popular technique, do yourself a favor and go ten toes in while we
explore those now. Say we want to save some default values for bittersweet chocolate, cocoa, and vanilla
to a closure our ChocolateChocolate() constructor can query. One way would be to define those as local
variables for a self-invoking function and then have its return value be the ChocolateChocolate()
constructor.
So, in the following sample, chocolateChocolate is churned with Callebaut cocoa and Madagascar
Bourbon vanilla due to closure, as Figure 6–14 displays, along with the function JavaScript assigns to
ChocolateChocolate.
var ChocolateChocolate = function () {
var _bittersweet = "Ghirardelli",
_cocoa = "Callebaut",
_vanilla = "Madagascar Bourbon";
return function (bittersweet, cocoa, vanilla) {
this.bittersweet = [1, "cup", bittersweet || _bittersweet];
this.cocoa = [3, "tbs", cocoa || _cocoa];
this.vanilla = [1, "bean", vanilla || _vanilla];
};
}();
ChocolateChocolate.prototype = {
heavyCream: [1, "cup", "Organic Valley"],
halfHalf: [1, "cup", "Organic Valley"],
sugar: [5/8, "cup"],
yolks: [6]
};
var chocolateChocolate = new ChocolateChocolate("Lindt");
console.dir(chocolateChocolate);
ChocolateChocolate.toString();