Examples of seven ways to create objects using JavaScript

This article mainly introduces the seven ways to create objects in JavaScript. Factory mode, constructor mode, prototype mode, etc. are explained in this article respectively. For specific operation steps, you can check the detailed explanation below. If you are interested, Friends, you can refer to it.

There are many ways to create objects in JavaScript. You can also create a single object through the Object constructor or object literal. Obviously, these two methods will generate a lot of repeated code and are not suitable for mass production. Next, we will introduce seven very classic ways to create objects. They also have their own advantages and disadvantages

Factory Pattern

function createPerson(name, job) {
 var o = new Object()
 o.name = name
 o.job = job
 o.sayName = function() {
  console.log(this.name)
 }
 return o
}
var person1 = createPerson(‘Jiang', ‘student')
var person2 = createPerson(‘X', ‘Doctor')

This factory function can be called countless times, and each time it will return an object containing two properties and one method

Although the factory pattern solves the problem of creating multiple similar objects, it does not solve the problem of creating multiple similar objects. Identify the problem, i.e. not knowing the type of an object

Constructor pattern

function Person(name, job) {
 this.name = name
 this.job = job
 this.sayName = function() {
  console.log(this.name)
 }
}
var person1 = new Person(‘Jiang', ‘student')
var person2 = new Person(‘X', ‘Doctor')

Not shown Create an object and use new to call this constructor. After using new, the following operations will be automatically performed

Create a new object
This new object will be executed [[prototype]] link
This new object Will be bound to this
of the function call and return this object
Using this method to create objects can detect the object type

person1 instanceof Object // true
person1 instanceof Person //true
But using constructors to create objects, each method is recreated once on each instance

Prototype pattern

function Person() {
}
Person.prototype.name = ‘Jiang'
Person.prototype.job = ‘student'
Person.prototype.sayName = function() {
 console.log(this.name)
}
var person1 = new Person()

Add information directly to the prototype object. The advantage of using a prototype is that all instance objects can share the properties and methods it contains without having to define object instance information in the constructor.

Prototype is a very important concept. It is explained in great detail in an article on understanding the relationship and difference between proto and prototype.

Simpler way of writing

function Person() {
}
Person.prototype = {
 name: ‘jiang',
 job: ‘student',
 sayName: function() {
  console.log(this.name)
 }
}
var person1 = new Person()

Set Person.prototype equal to an object created in the form of an object literal, but this will cause .constructor to no longer point to Person.

Using this method, the default Person.prototype object is completely rewritten, so the .constructor will not exist here

Person.prototype.constructor === Person // false

If you need this attribute, you can add it manually

function Person() {
}
Person.prototype = {
 constructor：Person
 name: ‘jiang',
 job: ‘student',
 sayName: function() {
  console.log(this.name)
 }
}

However, this method is not good enough, because the constructor attribute is disabled by default. Enumerable, if set directly like this, it will be enumerable. So when possible, the Object.defineProperty method

Object.defineProperty(Person.prototype, ‘constructor', {
 enumerable: false,
 value: Person
})

Disadvantages

uses prototypes, and all properties are Will be shared, this is a great advantage, but it will also bring some disadvantages

All attribute instances in the prototype are shared by many instances, this kind of sharing is very suitable for functions. It is barely possible for properties that contain basic values. After all, instance properties can mask prototype properties. But when reference type values ​​are used, problems will arise

function Person() {
}
Person.prototype = {
 name: ‘jiang',
 friends: [‘Shelby', ‘Court']
}
var person1 = new Person()
var person2 = new Person()
person1.friends.push(‘Van')
console.log(person1.friends) //[“Shelby”, “Court”, “Van”]
console.log(person2.friends) //[“Shelby”, “Court”, “Van”]
console.log(person1.friends === person2.friends) // true

friends exist in the prototype. Instances person1 and person2 point to the same prototype. If person1 modifies the referenced array, it will also Reflected in the instance person2

Combined use of constructor pattern and prototype pattern

This is the most widely used and most recognized creation Custom type methods. It can solve the shortcomings of the above patterns

Using this pattern allows each instance to have its own copy of instance attributes, but at the same time share a reference to the method

In this case, Even if an instance attribute modifies the value of a reference type, it will not affect the attribute values ​​of other instances

function Person(name) {
 this.name = name
 this.friends = [‘Shelby', ‘Court']
}
Person.prototype.sayName = function() {
 console.log(this.name)
}
var person1 = new Person()
var person2 = new Person()
person1.friends.push(‘Van')
console.log(person1.friends) //[“Shelby”, “Court”, “Van”]
console.log(person2.friends) // [“Shelby”, “Court”]
console.log(person1.friends === person2.friends) //false

Dynamic Prototype Mode

The dynamic prototype mode encapsulates all information in the constructor. During initialization, it determines whether a prototype needs to be initialized by detecting that a method that should exist is valid.

function Person(name, job) {
 // 属性
 this.name = name
 this.job = job

 // 方法
 if(typeof this.sayName !== ‘function') {
  Person.prototype.sayName = function() {
    console.log(this.name)
  }
 }

}
var person1 = new Person(‘Jiang', ‘Student')
person1.sayName()

Only if the sayName method does not exist, it will be added to the prototype. This code will only be executed the first time the constructor is called.

The prototype has been initialized and there is no need to make any modifications

The modifications made to the prototype here can be immediately reflected in all instances

Secondly, if The statement can check any property or method that should exist after initialization, so there is no need to use a lot of if statements to check every property and method, just check one.

Parasite constructor Pattern

The basic idea of ​​this pattern is to create a function, which only encapsulates the code that creates the object, and then returns the newly created object

function Person(name, job) {
 var o = new Object()
 o.name = name
 o.job = job
 o.sayName = function() {
  console.log(this.name)
 }
 return o
}
var person1 = new Person(‘Jiang', ‘student')
person1.sayName()

这个模式，除了使用new操作符并把使用的包装函数叫做构造函数之外，和工厂模式几乎一样

构造函数如果不返回对象，默认也会返回一个新的对象，通过在构造函数的末尾添加一个return语句，可以重写调用构造函数时返回的值

稳妥构造函数模式

首先明白稳妥对象指的是没有公共属性，而且其方法也不引用this。

稳妥对象最适合在一些安全环境中（这些环境会禁止使用this和new），或防止数据被其他应用程序改动时使用

稳妥构造函数模式和寄生模式类似，有两点不同:一是创建对象的实例方法不引用this，而是不使用new操作符调用构造函数

function Person(name, job) {
 var o = new Object()
 o.name = name
 o.job = job
 o.sayName = function() {
  console.log(name)
 }
 return o
}
var person1 = Person(‘Jiang', ‘student')
person1.sayName()

和寄生构造函数模式一样，这样创建出来的对象与构造函数之间没有什么关系，instanceof操作符对他们没有意义

The above is the detailed content of Examples of seven ways to create objects using JavaScript. For more information, please follow other related articles on the PHP Chinese website!