function aExtendsB( a,b ) {
var c = function() {};
c.prototype = b.prototype;
a.prototype = new c
}

I’ve just spent the whole day struggling with this exact problem where
“ChildClass.prototype = new ParentClass();”
involves an expensive constructor which relies on the DOM and other global variables.

Hopefully your code will set things right.

Does this depend on a library (prototype.js, mootools.js etc) for Class? A library-independant example would be nice.

if the prototype.constructor was set to SuperClass, then you get the following:
var sub = new SubClass();
alert(sub.constructor == SubClass); //alerts FALSE
alert(sub.constructor == SuperClass); //TRUE, but should it be?

Basically, what is happening is that when the function is created by the engine, it is given a prototype property…and it holds a property ‘constructor’ by default that points to the original fn the prototype was created for. That way, all instances of that ‘class’ automatically have a ‘constructor’ prop that points to the original constructor function. When the prototype is set to an instance of a different ‘class’, the prototype for the original constructor function then becomes that instance…which has a constructor prop that points to ITS original constructor function. So we just need to change the constructor prop for that instance to be the SubClass function…since it is being used as the SubClasses prototype this should be fine.

The only headaches this really causes is when you need to programmatically traverse the prototype chain. For this purpose, the superClass prop was added. BTW, this problem would exist even in the classical “SubClass.prototype = new SuperClass()” approach.

The only other way to get the prototype fixed would be to actually set the ‘constructor’ prop on every instance. That would require all instances be created via a factory method or something similar. It would be doable if there was like a magic _new property of every function that got called for every instance…then you could say:
SubClass._new = function(){
this.constructor = SubClass;
}
And in that case, you would definitely want to set SubClass.prototype.constructor to SuperClass…and then prototype traversal wouldn’t need a ’superClass’ prop.

Sorry for the long-winded answer…I know its rather confusing. Hope I made it more clear.

I’m scratching my head over one line of code, though. The last line is:

SubClass.prototype.constructor = SubClass;

For some reason I’m thinking that should be:

SubClass.prototype.constructor = SuperClass;

Was that a typo, or am I mixed up? (The latter is quite possible…)

Thanks!