javascript

Chapter 18: Advanced Techniques
In this example, the Person constructor assigns three properties using the this object: name , age , and
job . When used with the new operator, a new Person object is created, and the properties are assigned
onto it. The problem occurs when the constructor is called without the new operator. Since the this
object is bound at runtime, calling Person() directly maps this to the global object ( window ), resulting
in accidental augmentation of the wrong object. For example:
var person = Person(“Nicholas”, 29, “Software Engineer”);
alert(window.name); //”Nicholas”
alert(window.age); //29
alert(window.job); //”Software Engineer”
Here, the window object has been augmented with the three properties intended for a Person
instance, because the constructor was called as a regular function, omitting the new operator. This
issue occurs as a result of late binding of the this object, which was resolved to window in this case.
Since the name property of window is used to identify link targets as well as frames, this accidental
overwriting of the property could lead to other errors on the page. The solution is to create a
scope - safe constructor.
Scope - safe constructors first check to ensure that the this object is an instance of the correct type before
applying any changes. If not, then a new instance is created and returned. Consider this example:
function Person(name, age, job){
if (this instanceof Person){
this.name = name;
this.age = age;
this.job = job;
} else {
return new Person(name, age, job);
}
}
var person1 = Person(“Nicholas”, 29, “Software Engineer”);
alert(window.name); //””
alert(person1.name); //”Nicholas”
var person2 = new Person(“Shelby”, 34, “Ergonomist”);
alert(person2.name); //”Shelby”
The Person constructor in this code adds an if statement that checks to ensure that the this object is
an instance of Person , which indicates that either the new operator was used or the constructor was
called in the context of an existing Person instance. In either case, the object initialization continues as
usual. If this is not an instance of Person , then the constructor is called again with the new operator
and that value is returned. The result is that calling the Person constructor either with or without the
new operator returns a new instance of Person , avoiding any accidental property setting on the
global object.
590