How to use factory pattern and constructor to create objects in JavaScript?

Discuss several concepts in object-oriented: 1. Everything is an object, 2. Objects have encapsulation and inheritance characteristics, 3. Objects use messages to communicate with each other, and each has information hiding.

1. Factory pattern

ECMAScript can create objects through the factory pattern:

//工厂模式
function createObject(name, age) {
  var obj = new Object();                  //创建对象
  obj.name = name;                      //添加属性
  obj.age = age;
  obj.run = function () {                    //添加方法
    return this.name + this.age + '运行中...';
  };
  return obj;                            //返回对象引用
};
var obj1 = createObject('Lee', 100);          //创建第一个对象
var obj2 = createObject('Jack', 200);          //创建第二个对象
//alert(obj1.run());                          //打印第一个对象实例的run()方法
//alert(obj2.run());                          //打印第二个对象实例的run()方法

//alert(typeof obj1);
//alert(typeof obj2);
alert(obj1 instanceof Object); //true
alert(obj2 instanceof Object); //true

Objects created through the factory pattern are solved The problem of repeated instantiation, but the object recognition problem cannot be solved (all objects are Objects), so to solve the object recognition problem, we use the following constructor.

2. Constructor

//构造函数创建
function Person(name,age){  //所有构造函数对象都是Object
  this.name=name;
  this.age=age;
  this.run=function(){
    return this.name+this.age+"ing...";
  };
};
var person1=new Person('zhu1',100);
var person2=new Person('zhu2',200);
alert(person1.run());
alert(person2.run());

alert(person1 instanceof Object); //ture
alert(typeof person2);         //Person
alert(person2 instanceof Person);  // true
var person3=new Object();
Person.call(person3,'zhu3',300);//对象冒充,person3是Object类型，冒充Person类型
alert(person3.run());

In the constructor, this: represents the reference of the current scope object. If it is in the global scope, this represents the window object. If it is in the global scope, this represents the window object. The body of the constructor represents the object declared by the current constructor.

The constructor method solves the problem of repeated instantiation and the problem of object identification. Comparing the differences with the factory method, we can see:

1. The constructor method does not create objects explicitly. (new Object());

2. Directly assign property and method values ​​to this;

3. No return statement;

4. But use the constructor to create You must use the new operator;

The above is the detailed content of How to use factory pattern and constructor to create objects in JavaScript?. For more information, please follow other related articles on the PHP Chinese website!