Cuatro formas de crear múltiples objetos en JavaScript

Durante el proceso de desarrollo, a menudo nos encontramos con la necesidad de crear muchos objetos similares, que pueden tener muchas propiedades o métodos idénticos. Entonces, ¿cuáles son nuestros métodos para crear varios objetos? ¿Cuál es el mejor método? ¡Echemos un vistazo juntos!

1. Crear varios objetos: método literal

El método literal de un objeto es una de las formas más comunes de crear objetos. Las propiedades de los objetos creados en el método literal se pueden escribir, enumerar y configurar de forma predeterminada.

El siguiente código muestra cómo crear múltiples objetos usando métodos literales:

//Crear múltiples objetos usando métodos literales var person1 = {
    nombre: 'mermelada',
    edad: 18,
    dirección: 'Ciudad de Shanghai',
    comiendo: función () {
        console.log(este.nombre + 'Comer')
    }
}
var persona2 = {
    nombre: 'tom',
    edad: 20,
    dirección: 'Ciudad de Beijing',
    comiendo: función () {
        console.log(este.nombre + 'Comer')
    }
}
var persona3 = {
    nombre: 'encalado',
    edad: 19,
    dirección: 'Ciudad de Tianjin',
    comiendo: función () {
        console.log(este.nombre + 'Comer')
    }
}

经过上述示例代码我们可以看出，仅仅创建了3个对象就用了24行，可以看出字面量方式的弊端：创建同样的对象时，需要编写重复的代码太多。

2. Crear múltiples objetos: método de patrón de fábrica

El patrón de fábrica es en realidad un patrón de diseño común;
Generalmente tendremos un método de fábrica a través del cual podemos generar los objetos deseados.

El siguiente código muestra el funcionamiento de usar el método del modo de fábrica para crear múltiples objetos:

//Crea múltiples objetos usando la función de fábrica createPerson (nombre, edad, dirección); ) {
    var p = {}
    p.nombre = nombre
    p.age = edad
    p.dirección = dirección
    p.comer = funcion () {
        console.log(nombre + 'Comer')
    }
    volver p
}

var p1 = createPerson('jam', 19, 'Ciudad de Shanghai')
var p2 = crearPersona('tom', 14, 'Pekín')
var p3 = createPerson('li', 13, 'Ciudad de Tianjin')

p3.eating() // Cuando li está comiendo,

可以看出使用工厂模式方法创建了三个对象使用的代码明显比字面量少了好多行，but这就是最好的方式了吗？NO! NO! NO!
工厂模式方法的**弊端**就在于：以上述示例代码为例。当我们打印p1,p2,p3后，获取不到对象最真实的类型，比如p1是人还是动物还是工具

3. Crear múltiples objetos: método constructor

Constructor que creo que todos conocen

él. La llamada función constructora es una función que proporciona una plantilla para generar un objeto y describe la estructura básica del objeto. Un constructor puede generar múltiples objetos, cada uno con la misma estructura.

El siguiente código muestra el uso del método constructor para crear múltiples objetos:

// Especificación convencional, la primera letra del nombre del constructor está en mayúscula function Persona (nombre, edad, dirección) {
    este.nombre = nombre
    esta.edad = edad
    esta.dirección = dirección
    esto.comiendo = funcion () {
        console.log(este.nombre + 'Comer')
    }
    this.running = función () {
        console.log(este.nombre + 'ejecutando')
    }
}

var p1 = nueva Persona('jam', 20, 'Beijing')
var p2 = nueva Persona('tom', 14, 'Ciudad de Shanghai')
var p3 = nueva Persona('li', 13, 'Ciudad de Tianjin')

consola.log(p1)
// Resultados de salida // Persona {
// nombre: 'mermelada',       
// edad: 20,
// dirección: 'Pekín', 
// comiendo: [Función],
// ejecutando: [Función]
// }
p1.eating() // Jam

构造函数有个不成文的规范，那就是构造函数的名字首字母大写或者驼峰。
构造函数方式并不是最完美的创建多个对象的方式，也是有缺点的。
缺点：每个方法都要在每个实例上重新创建一遍，比如同样的eating方法和running方法都需要在p1,p2,p3的实例上去创建一遍，浪费很多的内存空间

. —El modo de combinación del método prototipo más constructor

es definir atributos de instancia en el constructor, luego solo es necesario pasar estos parámetros al crear el objeto. El objeto prototipo se utiliza para definir métodos y propiedades compartidas.

El siguiente código muestra cómo crear múltiples objetos usando prototipos y constructores:

function Persona (nombre, edad, dirección) {
    este.nombre = nombre
    esta.edad = edad
    esta.dirección = dirección
    esto.comiendo =
        this.running = función () {
            console.log(este.nombre + 'ejecutando')
        }
}
// Agrega el método de comer y el método de ejecución al prototipo, para que no necesites agregar el mismo método en la memoria cada vez que creas un objeto Person.prototype.eating = function () {.
    console.log(este.nombre + 'Comer')
}
Persona.prototipo.corriendo = funcion () {
    console.log(este.nombre + 'ejecutando')
}
var p1 = nueva Persona('jam', 20, 'Beijing')
var p2 = nueva Persona('tom', 14, 'Ciudad de Shanghai')
var p3 = nueva Persona('li', 13, 'Ciudad de Tianjin')

consola.log(p1)
//Resultado de salida:
// Persona {
// nombre: 'mermelada',       
// edad: 20,
// dirección: 'Pekín', 
// comiendo: [Función],
// ejecutando: [Función]
// }
p1.eating() //

最后的当然是压轴的呀，这种原型和构造函数方式是目前在ECMAScript中使用得最广泛、认同度最高的一种创建对象的方法。