Comments on: Subclassing in JavaScript, part 1

by: M

Mon, 12 May 2008 09:50:22 +0000

Hi,
I have tried an different techniques related to JavaScript inheritance subject.
The code and the explanation are to long to post them here so if anyone is interested to take a look over it you can find it at www.dotnetcaffe.net under JavaScript category. Fell free to criticize the code in any way you want…just don’t flame :).

by: Paul Crowley

Wed, 05 Sep 2007 10:20:48 +0000

Bill T: I thought you had to use “traits objects” to get similar behaviour in Self, am I wrong? Could you give a sample of Self code that illustrates the same behaviour in Self resulting from the use of clone()? Thanks!

by: Bill T

Wed, 05 Sep 2007 00:19:05 +0000

Actually, this is very much like Self’s clone method. Maybe an example use would clarify:

var parent = {a: 3};
var child = object(parent);
alert(child.a); // displays “3″
child.a = 4;
alert(child.a); // displays “4″
delete(child.a);
alert(child.a); // displays “3″
parent.a = 7;
alert(child.a); // displays “7″

by: Paul Crowley

Wed, 29 Aug 2007 07:36:33 +0000

Bill T: this is essentially the trick I discuss in Part 2. Although JavaScript calls this a “prototype” the name is misleading; it most closely resembles the vtable pointer of a class-based language.

by: Bill T

Tue, 28 Aug 2007 23:17:37 +0000

You write, "I don’t know how to make JavaScript behave like a sensible prototype-based language". Douglas Crockford writes:

function object(o) { function F() {} F.prototype = o; return new F(); }

Then, all you need to do is call object(foo) to create an object whose prototype is foo.

by: fantomx11

Fri, 27 Apr 2007 19:43:12 +0000

Here is my rewritten Child that doesn’t have the problem you describe and doesn’t require any helper functions to implement.

function Child() { Parent.prototype.constructor.apply(this); this.somethingelse = "somethingelse"; }

by: pdl_e

Fri, 13 Apr 2007 12:39:46 +0000

There is another approach to implement JavaScript inheritance - a “lazy” inheritance which has all benefits of prototype-based inheritance like typed classes, but also eliminates necessity to declare external scripts in proper order and automatically resolves and loads (if necessary) dependencies to external scripts that contains related classes.
You can find more about it on Alternate inheritance

by: Jeff Watkins

Tue, 12 Sep 2006 20:00:04 +0000

Sorry, your security code “feature” wiped out the long response, multiple examples, and explanations. I’ll try to simply post a corrected version of your last example:

function Parent() { } Parent.prototype.sharedArray= [];

function Child()
{
this.instanceMember= 5;
}
Child.prototype= new Parent;
Child.prototype.constructor= Child;

This is the correct way to implement a shared property in JavaScript.

The thing to keep in mind is that the object initialisers run for each new object created. Therefore, if you don’t want a per-instance property, you need to define it on the prototype rather than in the initialiser.

by: matthew

Mon, 24 Jul 2006 22:23:19 +0000

The last bit you describe about the children sharing the same parent instance reminds me of multiple virtual inheritance in C++. Except there you had to work to get such confusing behaviour - it seems so much easier in Javascript…!