Seven ways to create objects in JavaScript (summary, must-read)

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 The problem of object identification is not solved, that is, the type of an object cannot be known

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')

Create an object without display. 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
Return this object
Using this method to create objects can detect the object type

person1 instanceof Object // true
person1 instanceof Person //true
But using the constructor to create objects, each method must be 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 manually add it

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

But this method is still not good enough, it should be the constructor attribute The default is not enumerable, so if set directly, it will be enumerable. So when you can, the Object.defineProperty method

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

##disadvantages

uses prototypes, all All attributes will be shared, which 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, and person1 modifies the referenced array. , it will also be reflected in instance person2

Combined use of constructor pattern and prototype pattern

This is the most widely used and highly recognized A way to create custom types. 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 property modifies the value of a reference type, it will not affect the property 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 whether 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操作符对他们没有意义

上面是我整理给大家的，希望今后会对大家有帮助。

相关文章：

JS进行E-mail地址格式验证代码

Vue.js表单控件使用总结

Vue.js配置登录表单代码步骤剖析

The above is the detailed content of Seven ways to create objects in JavaScript (summary, must-read). For more information, please follow other related articles on the PHP Chinese website!