Design Patterns

CHAPTER 4 ■ INHERITANCE 47
attribute set to the prototype object. When it is just created, author[1].name is actually a link
back to the primitive Person.name. This is because of the asymmetry inherent in reading and
writing objects linked from the prototype. When you read the value of author[1].name, you are
getting the value linked from the prototype, provided you haven’t defined the name attribute
directly on the author[1] instance yet. When you write to author[1].name, you are defining
a new attribute directly on the author[1] object.
This example illustrates that asymmetry:
var authorClone = clone(Author);
alert(authorClone.name); // Linked to the primative Person.name, which is the
// string 'default name'.
authorClone.name = 'new name'; // A new primative is created and added to the
// authorClone object itself.
alert(authorClone.name); // Now linked to the primative authorClone.name, which
// is the string 'new name'.
authorClone.books.push('new book'); // authorClone.books is linked to the array
// Author.books. We just modified the
// prototype object's default value, and all
// other objects that link to it will now
// have a new default value there.
authorClone.books = []; // A new array is created and added to the authorClone
// object itself.
authorClone.books.push('new book'); // We are now modifying that new array.
This also illustrates why you must create new copies of data types that are passed by reference.
In the previous example, pushing a new value onto the authorClone.books array is actually
pushing it to Author.books. This is bad because you just modified the value not only for Author
but for any object inheriting from Author that has not yet overwritten the default. You must create
new copies of all arrays and objects before you start changing their members. It is very easy
to forget this and modify the value of the prototype object. This should be avoided at all costs;
debugging these types of errors can be very time-consuming. In these situations, you can use
the hasOwnProperty method to distinguish between inherited members and the object’s actual
members.
Sometimes prototype objects will have child objects within them. If you want to override
a single value within that child object, you have to recreate the entire thing. This can be done
by setting the child object to be an empty object literal and then recreating it, but that would
mean that the cloned object would have to know the exact structure and defaults for each
child object. In order to keep all objects as loosely coupled as possible, any complex child
objects should be created using methods:
var CompoundObject = {
string1: 'default value',
childObject: {
bool: true,
num: 10
}
}