javascript

Chapter 4: Variables, Scope, and Memory
Reference counting was initially used by Netscape Navigator 3.0 and was immediately met with a
serious issue: circular references. A circular reference occurs when object A has a pointer to object B and
object B has a reference to object A, such as in the following example:
function problem(){
var objectA = new Object();
var objectB = new Object();
}
objectA.someOtherObject = objectB;
objectB.anotherObject = objectA;
In this example, objectA and objectB reference each other through their properties, meaning that each
has a reference count of two. In a mark - and - sweep system, this wouldn ’ t be a problem because both
objects go out of scope after the function has completed. In a reference - counting system, though, objectA
and objectB will continue to exist after the function has exited because their reference counts will never
reach zero. If this function were called repeatedly, it would lead to a large amount of memory never being
reclaimed. For this reason, Netscape abandoned a reference -counting garbage-collection routine in favor
of a mark - and - sweep implementation in version 4.0. Unfortunately, that ’ s not where the reference -counting
problem ended.
Not all objects in IE are native JavaScript objects. Objects in the Browser Object Model (BOM) and
Document Object Model (DOM) are implemented as COM (Component Object Model) objects in C++,
and COM objects use reference counting for garbage collection. So even though the IE JavaScript engine
uses a mark - and - sweep implementation, any COM objects that are accessed in JavaScript still use
reference counting, meaning circular references are still a problem when COM objects are involved. The
following simple example demonstrates a circular reference with a COM object:
var element = document.getElementById(“some_element”);
var myObject = new Object();
myObject.element = element;
element.someObject = myObject;
This example sets up a circular reference between a DOM element ( element ) and a native JavaScript
object ( myObject ). The myObject variable has a property called element that points to element , and
the element variable has a property called someObject that points back to myObject . Because of this
circular reference, the memory for the DOM element will never be reclaimed even if it is removed from
the page.
To avoid circular - reference problems such as this, it ’ s best to break the connection between native
JavaScript objects and DOM elements when you ’ re finished using them. For example, the following code
cleans up the circular references in the previous example:
myObject.element = null;
element.someObject = null;
Setting a variable to null effectively severs the connection between the variable and the value it
previously referenced. The next time the garbage collector runs, these values will be deleted and the
memory will be reclaimed.
92