Inheritance

Prototype Chaining

　　Recall the relationship between consructors, prototypes and instances: each constructor has a prototype object that points back to the constructor, and instances have an internal pointer to the prototype. What if the prototype were actually an instance of another type? That would mean the prototype itself would have a pointer to a different prototype that, in turn, would have a pointer to another constructor. If that prototype were also an instance of another type, then the pattern would continue, forming a chain between instances and prototypes. This is the basic idea behind prototype chaining.

　　Implement prototype chaining involves the following code pattern:

function SuperType(){
    this.property = true;
}

SuperType.prototype.getSuperValue = function(){
    return this.property;
}

function SubType(){
    this.subproperty = false;
}

// inherit from SuperType
SubType.prototype = new SuperType();

SubType.prototype.getSubValue = function(){
    return this.subproperty;
};

var instance = new SubType();
alert(instance.getSuperValue());                      // true

 

Problems with Prototype Chaining

　　The major issue revolves around prototypes that contain reference values. When implementing inheritance using prototypes, the prototype actually becomes an instance of another type, meaning that what once were instance properties are now prototype properties. This issue is highlighted by the following example:

function SuperType(){
    this.colors = ["red", "blue", "green"];
}

function SubType(){}

// inherit from SuperType
SubType.prototype = new SuperType();

var instance1 = new SubType();
instance1.colors.push("black");
alert(instance1.colors);                          // "red, blue, green, black"
 
var instance2 = new SubType();
alert(instance2.colors);                          // "red, blue, green, black"

 

Constructor Stealing

　　The basic idea is quite simple: call the supertype constructor from within the subtype constructor. Keeping in mind that functions are simple objects that execute code in a particular context, the apply() and call() methods can be used to execute a constructor on the newly created object, as in this example:

function SuperType(name){
    this.name = name;
}

function SubType(){
    // inherit from SuperType passing in an argument
    SuperType.call(this, "Nicholas");

    // instance property
    this.age = 29;
}

var instance = new SubType();
alert(instance.name);                     // "Nicholas"
alert(instance.age);                        // 29

 Problems with Constructor Stealing

　　The downside to using constructor stealing exclusively is that it introduces the same problem as the constructor pattern for custom types: methods must be defined inside the constructor, so there's no function reuse. Furthermore, methods defined on the supertype's prototype are not accessible on the subtype, so all types can use only the constructor pattern. 

 

Combination Inheritance

　　The basic idea is to use prototype chaining to inherit properties and methods on the prototype and to use constructor stealing to inherit instance properties. This allows function reuse by defineing methods on the prototype and allows each instance to have its own properties. Consider the following: 

function SuperType(name){
    this.name = name;
    this.colors = ["red", "blue", "green"];  
}

SuperType.prototype.sayName = function(){
    alert(this.name);
};

function SubType(name, age){
    SuperType.call(this, name);
    this.age = age;
}

SubType.prototype = new SuperType();

SubType.prototype.sayAge = function(){
    alert(this.age);
};

var instance1 = new SubType("Nicholas", 29);
instance1.color.push("black");
alert(instance1.colors);           // "red, blue, green, black";
instance1.sayName();               // "Nicholas";
instance1.sayAge();                // 29;

var instance2 = new SubType("Greg", 27);
alert(instance2.colors);            // "red, blue, green";
instance2.sayName();                // "Greg";
instance2.sayAge();                 // 27

 

Prototypal inheritance

 　　Object.create() method accepts two arguments, an object to use as the prototype for a new object and an optional object defining additional properties to apply to the new object.

var person = {
    name:  "Nicholas",
    friends:  ["Shelby", "Court", "Van"]  
};

var anotherPerson = Object.create(person, {
    name:  {
        value: "Greg"
    }
});

anotherPerson.friends.push("Rob");

alert(anotherPerson.name);                       // "Greg"
alert(anotherPerson.friends);                      // "Shelby, Court, Van, Rob"

　　Prototypal inheritance is useful when there is no need for the overhead of creating separate constructor, but you still need an object to behave similiarly to another. Keep in mind that properties containing reference values will always share those values, similar to using the prototype pattern.

 

Parasitic Inheritance

　　The idea behind parasitic inheritance is similar to that of the parasitic constructor and factory patterns: create a funciton that does the inheritance, augments the object in some way and then returns the objects as if it did all the work. The basic parasitic inheritance pattern looks like this:

function createAnother(original){
    var clone = object(original);               // create a new object by calling a function
    clone.sayHi = function(){                  // augment the object in some way
        alert("hi");
    };
    return clone;                                  // return the object                 
}

　　The createAnother() function can be used in the following way:

var person = {
    name:  "Nicholas",
    friends:  ["Shelby", "Court", "Van"]
};

var anotherPerson = createAnother(person);
anotherPerson.sayHi();                 // "hi"

　　The code in this example returns a new object based on person. The anotherPerson object has all of the properties and methods of person but adds a new method called sayHi().

　　Parasitic inheritance is another pattern to use when you are concerned primarily with objects and not with custom types and constructors. Keep in mind that adding functions to objects using parasitic inheritance leads to inefficiencies related to function reuse, similar to the constructor pattern.

 

Parasitic Combination Inheritance

　　The most inefficient part of the Combination pattern is that the supertype constructor is always called twice: once to create the subtype's prototype, and once inside the subtype constructor. 

　　Parasitic combination inheritance uses constructor stealing to inherit properties but uses a hybrid form of prototype chaining to inherit methods. The basic idea is this: instead of calling the supertype constructor to assign the subtype's prototype, all you need is a copy of the supertype's prototype. Essentially, use parasitic inheritance to inherit from the supertype's prototype and then assign the result to the subtype's prototype. The basic pattern for parastic combination inheritance is as follows:

function inheritPrototype(SubType, SuperType){
    var prototype = object(SuperType.prototype);            // create object
    prototype.constructor = SubType;                              // augment object
    SubType.prototype = prototype;                                 // assign object  
}

　　A call to inheritPrototype() can replace the subtype prototype assignment in the previous example, as shown here:

function SuperType(name){
    this.name = name;
    this.colors = ["red", "blue", "green"];
}

SuperType.prototype.sayName = function(){
    alert(this.name);
};

function SubType(name, age){
    SuperType.call(this, name);
    this.age = age;
}

inheritPrototype(SubType, SuperType);

SubType.prototype.sayAge = function(){
    alert(this.age);
};

　　This example is more efficient in that the SuperType constructor is being called only one time, avoiding having unneccessary and unused properties on SubType.prototype. Furthermore, the prototype chain is kept intact, so both instanceof and isPrototypeOf() behave as they would normally. Parasitic combination inheritance is considered the most optimal inheritance paradigm for reference types.