AJAX In Action [149]
First, let’s examine the concept of memory management in general.
8.3.1 Avoiding memory leaks
Any program can “leak” memory (that is, claim system memory and then fail to release it when finished), and the allocation and deallocation of memory are a major concern to developers using unmanaged languages such as C. JavaScript is a memory-managed language, in which a garbage-collection process automatically handles the allocation and deallocation of memory for the programmer. This takes care of many of the problems that can plague unmanaged Licensed to jonathan zheng JavaScript memory footprint 303 code, but it is a fallacy to assume that memory-managed languages can’t generate memory leaks. Garbage-collection processes attempt to infer when an unused variable may be safely collected, typically by assessing whether the program is able to reach that variable through the network of references between variables. When a variable is deemed unreachable, it will be marked as ready for collection, and the associated memory will be released in the next sweep of the collector (which may be at any arbitrary point in the future). Creating a memory leak in a managed language is as simple as forgetting to dereference a variable once we have finished with it. Let’s consider a simple example, in which we define an object model that describes household pets and their owners. First let’s look at the owner, described by the object Person: function Person(name){ this.name=name; this.pets=new Array(); } A person may have one or more pets. When a person acquires a pet, he tells the pet that he now owns it: Person.prototype.addPet=function(pet){ this.pets[pet.name]=pet; if (pet.assignOwner){ pet.assignOwner(this); } } Similarly, when a person removes a pet from his list of pets, he tells the pet that he no longer owns it: this.removePet(petName)=function{ var orphan=this.pets[petName]; this.pets[petName]=null; if (orphan.unassignOwner){ orphan.unassignOwner(this); } } The person knows at any given time who his pets are and can manage the list of pets using the supplied addPet() and removePet() methods. The owner informs the pet when it becomes owned or disowned, on the assumption that each pet adheres to a contract (in JavaScript, we can leave this contract as implicit and check for adherence to the contract at runtime). Licensed to jonathan zheng 304 CHAPTER 8 Performance Pets come in several shapes and sizes. Here we define two: a cat and a dog. They differ in the attitude that they take toward being owned, with a cat paying no attention to whom it is owned by, whereas a dog will attach itself to a given owner for life. (I apologize to the animal world for gross generalization at this point!) So our definition of the pet cat might look like this: function Cat(name){ this.name=name; } Cat.prototype.assignOwner=function(person){ } Cat.prototype.unassignOwner=function(person){ } The cat isn’t interested in being owned or disowned, so it provides empty implementations of the contractual methods. We can define a dog, on the other hand, that slavishly remembers who its owner is, by continuing to hold a reference to its master after it has been disowned (some dogs are like that!): function Dog(name){ this.name=name; } Dog.prototype.assignOwner=function(person){ this.owner=person; } Dog.prototype.unassignOwner=function(person){ this.owner=person; } Both Cat and Dog objects are badly behaved implementations of Pet. They stick to the letter of the contract of being a pet, but they don’t follow its