javascript

Chapter 6: Object-Oriented Programming
(continued)
}
};
return o;
var person = new Person(“Nicholas”, 29, “Software Engineer”);
person.sayName(); //”Nicholas”
In this example, the Person constructor creates a new object, initializes it with properties and methods,
and then returns the object. This is exactly the same as the factory pattern except that the function is
called as a constructor, using the new operator. When a constructor doesn ’ t return a value, it returns the
new object instance by default. Adding a return statement at the end of a constructor allows you to
override the value that is returned when the constructor is called.
This pattern allows you to create constructors for objects that may not be possible otherwise. For
example, you may want to create a special array that has an extra method. Since you don ’ t have direct
access to the Array constructor, this pattern works:
function SpecialArray(){
//create the array
var values = new Array();
//add the values
values.push.apply(values, arguments);
//assign the method
values.toPipedString = function(){
return this.join(“|”);
};
}
//return it
return values;
var colors = new SpecialArray(“red”, “blue”, “green”);
alert(colors.toPipedString()); //”red|blue|green”
In this example, a constructor called SpecialArray is created. In the constructor, a new array is created
and initialized using the push() method (which has all of the constructor arguments passed in). Then a
method called toPipedString() is added to the instance, which simply outputs the array values as a
pipe - delimited list. The last step is to return the array as the function value. Once that is complete, the
SpecialArray constructor can be called, passing in the initial values for the array, and
toPipedString() can be called.
A few important things to note about this pattern: There is no relationship between the returned object
and the constructor or the constructor ’ s prototype; the object exists just as if it were created outside of a
constructor. Therefore, you cannot rely on the instanceof operator to indicate the object type. Due to
these issues, this pattern should not be used when other patterns work.
168