Inheritance question

[Christopher Benson-Manica]

Is this code both correct and canonical?

function foo( arg ) {
this.initialize( arg );
}

foo.prototype.initialize=function( arg ) {
// Initialize based on arg
}

function myFoo( arg ) {
this.initialize( arg );
// Set other custom properties of myFoo
}

myFoo.prototype=new foo( '' ); // type of arg irrelevant here
myFoo.prototype.constructor=myFoo;

Basically I want to call the superclass constructor from the subclass'
constructor and then do some initialization of my own. In case it
helps, in C++ I would do something like

class B : public A {
B( int arg ) : A( arg ) {/*whatever*/}
};

--
Christopher Benson-Manica | I *should* know what I'm talking about - if I
ataru(at)cyberspace.org | don't, I need to know. Flames welcome.

[Douglas Crockford]

> Basically I want to call the superclass constructor from the subclass'

constructor and then do some initialization of my own.

My advice is to not try to apply C++ patterns to JavaScript. It will
only break your heart. JavaScript is a prototypal language, not a
classical language. It is flexible enough to simulate classical
patterns, but that is not what it is good at. JavaScript even tries to
look somewhat classical with that contructor jazz, but I think that it
is just confusing, as you have reported.

You will be more effective working with prototypes directly. First,
you need a function that makes a new empty object that inherits from
an existing one. This feature should be in the language but isn't, but
that's ok because it is really easy to write:

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

So,
b = object(a);

The new b appears to have all of the properties of a, but it isn't a
copy. It inherits. This is class-free inheritance.

Having that in hand, you can make an object that is like what you
want, and make lots of instances that point to it and inherit from it.

You can have maker functions that return a specialized object. You can
have a makerB function that calls a makerA function, taking its
objectA result, augmenting it, and returning it as an objectB. I call
this Parasitic Inheritance.

http://www.crockford.com/javascript

[VK]

Christopher Benson-Manica wrote:

Is this code both correct and canonical?

function foo( arg ) {
this.initialize( arg );
}

foo.prototype.initialize=function( arg ) {
// Initialize based on arg
}

function myFoo( arg ) {
this.initialize( arg );
// Set other custom properties of myFoo
}

myFoo.prototype=new foo( '' ); // type of arg irrelevant here
myFoo.prototype.constructor=myFoo;

Basically I want to call the superclass constructor from the subclass'
constructor and then do some initialization of my own. In case it
helps, in C++ I would do something like

class B : public A {
B( int arg ) : A( arg ) {/*whatever*/}
};

--
Christopher Benson-Manica | I *should* know what I'm talking about - if I
ataru(at)cyberspace.org | don't, I need to know. Flames welcome.

JavaScript is *not* Java, but the background "thinking" yet closer to
Java than to C++ because guys who did the first prototype had Java book
on their tables. It is not my relevation - you may read LiveScript
story yourselve.

/* Java */

public class Employee {
static String store = "ACME, Inc.";
String name = "John Doe";
}

public class Manager extends Employee {
super();
public String department = "Dep. 001";
}
/* JavaScript */
function Employee() {
this.name = "John Doe";
}
Employee.prototype.store = "ACME, Inc.";

function Manager() {
Employee.call(this);
this.department = "dep. 001";
}

[VK]

Douglas Crockford wrote:

You can
have a makerB function that calls a makerA function, taking its
objectA result, augmenting it, and returning it as an objectB. I call
this Parasitic Inheritance.

With all my respect you would call it just "Inheritance" w/o any
epithets. This is how Inheritance is described in C++, Java and other
languages.

If ObjectA do not fully satisfy your needs, you don't patch or hack it.
You leave the old horse (ObjectA) alone, you create new object ObjectB,
inherit all useful stuff from ObjectA (super object) and extend ObjectB
with missing properties/methods.
This is how nearly all native classes in C++ / Java are build - and it
would be too loud to call these languages "a set of parasiting
classes".

Prototype change/replacement was the only way until well official but
long neglected call() and apply() methods went into wide use and
support.
But now there is a possibility to work in the conventional OOP
paradigm, so why not follow it?

Unless I'm missing something crucial.

[Douglas Crockford]

> Unless I'm missing something crucial.

So it would seem.