javascript

Chapter 6: Object-Oriented Programming
In this code, the createAnother() function accepts a single argument, which is the object to base a new
object on. This object, original , is passed into the object() function, and the result is assigned to
clone . Next, the clone object is changed to have a property called newProperty . The last step is to
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. The object() method is not required for parasitic inheritance; any
function that returns a new object fits the pattern.
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
Combination inheritance is the most often - used pattern for inheritance in JavaScript, though it is not
without its inefficiencies. The most inefficient 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 property 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);
//second call to SuperType()
}
this.age = age;
(continued)
179