javascript

Chapter 7: Anonymous Functions
The two highlighted lines show the difference between this example and the previous one. Before
defining the anonymous function, a variable named that is assigned equal to the this object. When the
closure is defined, it has access to that , since it is a uniquely named variable in the containing function.
Even after the function is returned, that is still bound to object , so calling object.getNameFunc()()
returns “ My Object ” .
Both this and arguments behave in this way. If you want access to a containing scope ’ s arguments
object, you ’ ll need to save a reference into another variable that the closure can access.
Memory Leaks
The way closures work causes particular problems in Internet Explorer due to the different garbage -
collection routines used for JScript objects versus COM objects (discussed in Chapter 4 ). Storing a scope
in which an HTML element is stored effectively ensures that the element cannot be destroyed. Consider
the following:
function assignHandler(){
var element = document.getElementById(“someElement”);
element.onclick = function(){
alert(element.id);
};
}
This code creates a closure as an event handler on element , which in turn creates a circular reference
(events are discussed in Chapter 12 ). The anonymous function keeps a reference to the
assignHandler() function ’ s activation object, which prevents the reference count for element from
being decremented. As long as the anonymous function exists, the reference count for element will be at
least 1, which means the memory will never be reclaimed. This situation can be remedied by changing
the code slightly, as shown here:
function assignHandler(){
var element = document.getElementById(“someElement”);
var id = element.id;
element.onclick = function(){
alert(id);
};
}
element = null;
In this version of the code, a copy of element ’ s ID is stored in a variable that is used in the closure,
eliminating the circular reference. That step alone is not enough, however, to prevent the memory
problem. Remember: the closure has a reference to the containing function ’ s entire activation object,
which contains element . Even if the closure doesn ’ t reference element directly, a reference is still stored
in the containing function ’ s activation object. It is necessary, therefore, to set the element variable equal
to null . This dereferences the COM object and decrements its reference count, assuring that the memory
can be reclaimed when appropriate.
190