javascript

Chapter 6: Object-Oriented Programming
In this example, the SuperType constructor defines a property colors that contains an array
(a reference value). Each instance of SuperType has its own colors property containing its own array.
When SubType inherits from SuperType via prototype chaining, SubType.prototype becomes an
instance of SuperType and so it gets its own colors property, which is akin to specifically creating
SubType.prototype.colors . The end result: all instances of SubType share a colors property. This is
indicated as the changes made to instance1.colors are reflected on instance2.colors .
A second issue with prototype chaining is that you cannot pass arguments into the supertype constructor
when the subtype instance is being created. In fact, there is no way to pass arguments into the supertype
constructor without affecting all of the object instances. Due to this and the aforementioned issue with
reference values on the prototype, prototype chaining is rarely used alone.
Constructor Stealing
In an attempt to solve the inheritance problem with reference values on prototypes, developers began
using a technique called constructor stealing (also sometimes called object masquerading or classical
inheritance). The basic idea is quite simple: call the supertype constructor from within the subtype
constructor. Keeping in mind that functions are simply 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(){
this.colors = [“red”, “blue”, “green”];
}
function SubType(){
//inherit from SuperType
SuperType.call(this);
}
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”
The highlighted lines in this example show the single call that is used in constructor stealing. By
using the call() method (or alternately, apply() ), the SuperType constructor is called in the context
of the newly created instance of SubType . Doing this effectively runs all of the object-initialization code
in the SuperType() function on the new SubType object. The result is that each instance has its own
copy of the colors property.
175