javascript

Chapter 18: Advanced Techniques
There is a caveat to scope - safe constructors. By implementing this pattern, you are locking down the
context in which the constructor can be called. If you ’ re using the constructor - stealing pattern of
inheritance without also using prototype chaining, your inheritance may break. Here is an example:
function Polygon(sides){
if (this instanceof Polygon) {
this.sides = sides;
this.getArea = function(){
return 0;
};
} else {
return new Polygon(sides);
}
}
function Rectangle(width, height){
Polygon.call(this, 2);
this.width = width;
this.height = height;
this.getArea = function(){
return this.width * this.height;
};
}
var rect = new Rectangle(5, 10);
alert(rect.sides); //undefined
In this code, the Polygon constructor is scope - safe, whereas the Rectangle constructor is not. When a
new instance of Rectangle is created, it should inherit the sides property from Polygon through the
use of Polygon.call() . However, since the Polygon constructor is scope - safe, the this object is not an
instance of Polygon , so a new Polygon object is created and returned. The this object in the Rectangle
constructor is not augmented, and the value returned from Polygon.call() is not used, so there is no
sides property on the Rectangle instance.
This issue resolves itself if prototype chaining or parasitic combination is used with constructor stealing.
Consider the following example:
function Polygon(sides){
if (this instanceof Polygon) {
this.sides = sides;
this.getArea = function(){
return 0;
};
} else {
return new Polygon(sides);
}
}
function Rectangle(width, height){
Polygon.call(this, 2);
this.width = width;
this.height = height;
(continued)
591