javascript

Chapter 4: Variables, Scope, and Memory
In this figure, the rectangles represent specific execution contexts. An inner context can access everything
from all outer contexts through the scope chain, but the outer contexts cannot access anything within an
inner context. The connection between the contexts is linear and ordered. Each context can search up the
scope chain for variables and functions, but no context can search down the scope chain into another
execution context. There are three objects in the scope chain for the local context of swapColors(): the
swapColors() variable object, the variable object from changeColor(), and the global variable object.
The local context of swapColors() begins its search for variable and function names in its own variable
object before moving along the chain. The scope chain for the changeColor() context has only two objects:
its own variable object and the global variable object. This means that it cannot access the context of
swapColors() .
Function arguments are considered to be variables and follow the same access rules as any other variable
in the execution context.
Scope Chain Augmentation
Even though there are only two types of execution contexts, global and local (function), there are other
ways to augment the scope chain. Certain statements cause a temporary addition to the front of the
scope chain that is later removed after code execution. There are two times when this occurs, specifically
when execution enters either of the following:
❑
❑
The catch block in a try - catch statement
A with statement
Both of these statements add a variable object to the front of the scope chain. For the with statement, the
variable object contains variable declarations for all properties and methods of the specified object; for
the catch statement, the variable object contains a declaration for the thrown error object. These variable
objects are read - only, so variables declared in a with or catch statement are added to the execution
context ’ s variable object. Consider the following:
function buildUrl() {
var qs = “?debug=true”;
with(location){
var url = href + qs;
}
}
return url;
In this example, the with statement is acting on the location object, so a variable object containing all
of location ’ s properties and methods is added to the front of the scope chain. There is one variable, qs ,
defined in the buildUrl() function. When the variable href is referenced, it ’ s actually referring to
location.href , which is in its own variable object. When the variable qs is referenced, it ’ s referring to
the variable defined in buildUrl() , which is in the function context ’ s variable object. Inside the with
statement is a variable declaration for url . Because this variable object is read - only, url becomes part of
the function ’ s context and can, therefore, be returned as the function value.
87