There is a really great article on inheritance in Javascript tucked away in the Rochester Institute of Technology website :
http://www.cs.rit.edu/~atk/JavaScript/manuals/jsobj/
Dated from 1997 and very hard to find using Google, this article offered me the perfect solution to the problem I had in front of me, namely, having objects with constructors that also use inheritance.
Incorporating constructors in Javascript is usually done using the ‘static’ notation, where one method contains other methods :
function MyObject(myInitialData) {
this.initalData = myInitialData;
this.aMethod= new function() {
getSoftware : null
};
this.anotherMethod = new function() {
return this.initalData;
}
}
Everything between the line :
function myObject(myInitialData) {
and the first method would be considered a constructor, and you can add as many parameters as you want to the outer method (in my case it is just one: myInitialData).
The only problem with this technique is that you can’t define the object as being of some other kind of object. In other words you can’t have MyObject be anything else.
Using the dynamic Javascript notation you can create an object to be of something else :
var b = Object.create(a);
b.x = function() {}
b.y = function() {}
b.z = function() {}
ie. b is an a;
you can also add a constructor-like method, called init().
Example :
var b = Object.create(Building);
b.init = function(name) {
this.name = name;
this.createFoundations();
};
b.createFoundations = function(){
builder.buildFoundations();
}
b.printName= function(
alert(this.name)
);
If you have something like this, you have inheritance (It inherits Building), and your init() becomes your constructor. But it is not a real constructor because you have to remember to call it after the create. Constructors are a way of forcing the programmer to execute some initial code.
From the above website, the solution would be to set the prototype after defining the method using the first technique :
function MyObject(myInitialData) {
this.initalData = myInitialData;
this.aMethod = new function(){
getSoftware : null
};
this.anotherMethod = new function(){
return this.initalData;
}
}
MyObject.prototype = new Building;
Using this technique, we have inheritance, ie MyObject is a Building, and we have a constructor too.
This is how we do it now!
