Which two code segments should you use?

Parasitic Combination Inheritance

Combination inheritance is the most often-used pattern for inheritance in JavaScript, though
it is not without its ineffi ciencies. The most ineffi cient part of the pattern is that the supertype
constructor is always called twice: once to create the subtype’s prototype, and once inside the
subtype constructor. Essentially, the subtype prototype ends up with all of the instance properties of
a supertype object, only to have it overwritten when the subtype constructor executes. Consider the
combination inheritance example again:

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); //highlighted lines – second call to SuperType()

this.age = age;
}

SubType.prototype = new SuperType(); //highlighted lines – first call to SuperType()
SubType.prototype.constructor = SubType;
SubType.prototype.sayAge = function(){
alert(this.age);
};

The highlighted lines of code indicate when SuperType constructor is executed. When this code is
executed, SubType.prototype ends up with two properties: name and colors. These are instance
properties for SuperType, but they are now on the SubType’s prototype. When the SubType constructor
is called, the SuperType constructor is also called, which creates instance properties name and colors
on the new object that mask the properties on the prototype.

As you can see, there are two sets of name and colors properties: one on the instance and one on
the SubType prototype. This is the result of calling the SuperType constructor twice. Fortunately,
there is a way around this.