Question

When defining a class as such:

var namespace = {};
namespace.appleClass = function() {
   this.collection = [];
};

namespace.appleClass.prototype.methodOne = function(arg) {
   this.collection.push(arg);
};

The way to get rid of this.collection is simple.

this.collection.length = 0;

My question is what happens to the methods defined above (on namespace.appleClass.prototype). How does JavaScript deal with them? Where is a function ‘stored’? How can that storage be freed up?

The above class can be used as such.

var apple = new appleClass();
appleClass.methodOne(2);
appleClass.collection[0]// will be equal to two etc..

I know how to null DOM references, COM references and the long story behind the delete operator. What I don’t know is what is the best way to delete functions and references to them from a ‘custom prototype’ or ‘class’ to say so.

Answer 1

The way to get rid of this.collection is simple.

this.collection.length = 0;

That doesn’t get rid of the array, that just truncates it so it has no entries. To actually get rid of the array entirely, do delete this.collection (which will remove the property referring to the array entirely, making the array eligible for garbage collection) or this.collection = null (which will release the reference to the array, making it eligible for garbage collection, but not remove the property, which will still exist with the value null).

Anything that was in this.collection and which isn’t referred to elsewhere will then be eligible for garbage collection. When (or indeed whether) this happens is entirely down to the JavaScript implementation.

And that’s the key point, really: To "manage" memory in JavaScript, you just make sure nothing is referring to the thing you don’t want anymore. Usually that falls out of your application logic anyway (you don’t want it anymore, so you drop your references to it). If you design your code keeping in mind how closures work, for the most part, you don’t need to worry about memory management.

Re your questions in the comments on the question:

I am taking about the methods found under namespace.appleClass.prototype. How does JavaScript deal with them? Where is a function ‘stored’? How can that storage be freed up?

The function object is stored in heap (almost certainly; if it were only referenced by a local variable, some engines like Google’s V8 might well use stack for it); where the code is is implementation-dependent. A reference to the function object (and therefore to its code) is stored in the property on the prototype object on appleClass. There is only one of these functions, which is shared by all instances created by new namespace.appleClass via the prototype chain. There is not a separate copy of the function for each instance (just a separate reference to it), and thus there is no need to worry about "cleaning up" that function on instances.

If you no longer need that function at all, anywhere in your code (e.g., all appleClass instances no longer need it), you can get rid of it via delete namespace.appleClass.prototype.methodOne). That will remove the property from the prototype, which releases its reference to the function object, which releases its reference to the function code, all of which are then eligible for garbage collection. But this would be very unusual, and a single function doesn’t take up much memory in any case.