Detailed explanation of object factory function and constructor in JavaScript design pattern

Detailed explanation of object factory function and constructor in JavaScript design pattern_Basic knowledge

WBOY

Release： 2016-05-16 15:48:18

Original

1244 people have browsed it

The following is a detailed text explanation and code analysis to share with you the knowledge about the object factory function and constructor of the JavaScript design pattern.

Overview Using object literals, or dynamically adding new members to empty objects, is the simplest and easiest way to create objects. However, in addition to these two commonly used methods of object creation, JavaScript also provides other methods to create objects. 1).Use factory function to create objects. We can write a function. The function of this function is to create objects and convert them.

Overview

Using object literals, or dynamically adding new members to empty objects, is the simplest and easiest way to create objects.
However, in addition to these two commonly used methods of object creation, JavaScript also provides other methods to create objects.
1). Create objects using factory functions

We can write a function whose function is to create objects, which can be called the "object factory method".

Copy code The code is as follows:

//factory function 

function createPerson(name, age, job) {                                   
var o = new Object();                            
o.name = name;
o.age = age;
o.job = job;
o.sayName = function () {                                          
console.info(this.name); 

};       

return o; } //Use factory function to create object  

var person1 = createPerson('Zhang San', 29, 'Software Engineer');  

var person2 = createPerson('李思', 40, 'Doctor');

2). Define object constructor

a). The first letter of the object constructor is capitalized b). Use this keyword internally to add members to the object

c). Use the new keyword to call the object constructor

Copy code

The code is as follows: //Define object "constructor" function function Person(name, age, job) { this.name = name; this.age = age; this.job = job;

this.sayName = function () {

console.info(this.name); };
} //Use new to call the object constructor to create an object
var p1 = new Person('Zhang San', 29, 'Software Engineer');
var p2 = new Person('李思', 40, 'Doctor');

A "constructor" called in the normal way

The constructor is actually a function. The difference is that when calling it, a "new" keyword must be added. If this keyword is not added, the call to it is considered an ordinary function call.

Copy code

The code is as follows:

//As a constructor called by a normal function, attributes added through this,

//Becomes the properties and methods of the window object. console.info(window.name);//Zhang San console.info(window.age); //29 console.info(window.job); //Software Engineer

The object constructor looks like this:

Copy code

The code is as follows:

function Person (name) {

this.name = name; this.say = function () { return "I am " this.name; }; }

Actually it’s like this (signaling):

Copy code

The code is as follows:

function Person (name) {

// var this = {};

this.name = name;

this.say = function () {

return "I am " this.name;

};

// return this;

}

Work done by the constructor

1. Create a new object
2. Let this of the constructor refer to the newly created object
3. Execute the code in the constructor, which usually completes the work of adding properties to the new object
4. Return the newly created object reference to the outside world.
The difference between object constructor and object factory method

1. There is no explicit object creation code in the object constructor
2. The attributes and methods that the new object should have are added through this reference.
3. There is no return statement in the object constructor
Usually the first letter of the object constructor is set to uppercase to distinguish it from ordinary functions.
The constructor property of the object

a). Use the object factory function to create objects, and the constructor property of each object refers to Object()

Copy code The code is as follows:

var person = createPerson('Zhang San', 29, 'Software Engineer');
//Use factory method to create objects,

The constructor attribute refers to the Object() function
console.info(person1.constructor === Object);

//true

b). Use the object constructor to create objects, and the constructor attribute of each object refers to this constructor

Copy code The code is as follows:

var p = new Person('Zhang San', 29, 'Software Engineer');
//Create an object using the object constructor,
//The constructor attribute of each object refers to this constructor
console.info(p.constructor === Person);
//True How to avoid "forgetting" new? You can use arguments.callee to solve this problem
//Understand the role of arguments.callee
function TestArgumentsCallee()
{                                                       console.info(this);
console.info(this instanceof TestArgumentsCallee); console.info(this instanceof arguments.callee);
};
TestArgumentsCallee(); //window
//false                                                                                  //false
new TestArgumentsCallee(); //TestArgumentsCallee                                                             //true

//true

So, you can use arguments.callee directly

Copy code

The code is as follows:

//Avoid forgetting new
function MyObject(value)
{
if (!(this instanceof arguments.callee))

{ //If the caller forgets to add new, just add new and call again

return new MyObject(value);

}
this.prop = value;
}
//Testing
var obj1 = new MyObject(100);
console.info(obj1.prop);//100
var obj2 = MyObject(200);
console.info(obj2.prop); //200

The above content is a detailed explanation of the object factory function and constructor of the JavaScript design pattern. I hope you like it.