javascript

Chapter 6: Object-Oriented Programming
The object() function creates a temporary constructor, assigns a given object as the constructor ’ s
prototype, and returns a new instance of the temporary type. Essentially, object() performs a shadow
copy of any object that is passed into it. Consider the following:
var person = {
name: “Nicholas”,
friends: [“Shelby”, “Court”, “Van”]
};
var anotherPerson = object(person);
anotherPerson.name = “Greg”;
anotherPerson.friends.push(“Rob”);
var yetAnotherPerson = object(person);
yetAnotherPerson.name = “Linda”;
yetAnotherPerson.friends.push(“Barbie”);
alert(person.friends);
//”Shelby,Court,Van,Rob,Barbie”
This is the way Crockford advocates using prototypal inheritance: You have an object that you want to
use as the base of another object. That object should be passed into object(), and the resulting object
should be modified accordingly. In this example, the person object contains information that should be
available on another object, so it is passed into the object() function, which returns a new object. The
new object has person as its prototype, meaning that it has both a primitive value property and a
reference value property on its prototype. This also means that person.friends is shared not only by
person , but also with anotherPerson and yetAnotherPerson . Effectively, this code has created two
clones of person .
Prototypal inheritance is useful when there is no need for the overhead of creating separate constructors
but you still need an object to behave similarly to another. Keep in mind that properties containing
reference values will always share those values, similar to using the prototype pattern.
Parasitic Inheritance
Closely related to prototypal inheritance is the concept of parasitic inheritance, another pattern popularized
by Crockford. The idea behind parasitic inheritance is similar to that of the parasitic constructor and factory
patterns: create a function that does the inheritance, augments the object in some way, and then returns the
object as if it did all the work. The basic parasitic inheritance pattern looks like this:
function createAnother(original){
var clone = object(original);
clone.sayHi = function(){
alert(“hi”);
};
return clone;
}
//create a new object by calling a function
//augment the object in some way
//return the object
178