Breve análisis del método para crear objetos JavaScript

1. Modelo de fábrica

 Función persona (nombre, edad) {var p = new Object (); p.name = nombre; p.age = edad; P.ShowMessage = function () {console.log ("nombre:"+this.name+"edad:"+this.age); } return p;} var p1 = persona ("k1", 28); var p2 = persona ("k2", 29); console.log (p1.ShowMessage == P2.ShowMessage); // False no es el mismo método de exhibición console.log (P1.constructor); // [Object] son todos los objetos

El defecto del patrón de fábrica es que el problema del reconocimiento de objetos no se resuelve, y el método de exhibición de cada objeto no es el mismo método (cada método se recrea en cada instancia de objeto), que aumenta la sobrecarga

2. Modo constructor

 Función Persona (nombre, edad) {this.name = name; this.age = edad; this.showMessage = function () {console.log ("nombre:"+this.name+"edad:"+this.age); }} var p1 = nueva persona ("k1", 28); var p2 = nueva persona ("k2", 29); console.log (p1.showmessage == p2.showmessage); // falso no es el mismo método de showmessage console.log (p1.constructor); // [persona] console.log (instancia p1 de la persona); // verdadero consolador

El patrón del constructor resuelve el problema del reconocimiento de objetos, pero el método de exhibición de cada objeto no es el mismo método (cada método se recrea en cada instancia de objeto), que aumenta la sobrecarga

3. Modo prototipo

 function Person () {} persona.prototype.name = "k"; persona.prototype.age = 29; persona.prototype.showmessage = function () {console.log ("name:"+this.name+"edad:"+this.age);}; var p1 = new Person (); p1.showmessage (); // name: k age); Persona (); p2.showMessage (); // nombre: k edad: 29console.log (p1.showmessage == P2.ShowMessage); // true -La referencia es la misma función console.log (p1.constructor) // [persona] -reconocimiento de reconocimiento de console.log (p1 instancia de persona) // verdadero -objeto reconocimiento de reconocimiento console.log (persona.prototype.isprototypeOf (p1)); // trueConsole.log (object.getPrototypeOf (p1) == Person.prototype); // verdadero

El patrón de prototipo resuelve el problema de "Cada método se recrea en cada instancia de objeto" y también resuelve el problema del reconocimiento de objetos.

Un gran problema con el modo prototipo es que todos los objetos, variables y funciones montadas bajo el prototipo de función son compartidas por todas las instancias de la función. Aunque se puede acceder a las propiedades del prototipo a través de las instancias P1 y P2, el valor de la propiedad no puede modificarse. Por ejemplo, p1.name = "k1", solo agrega una propiedad de nombre = "k1" en la instancia p1, y no cambia a prototipo.name. Está bien si es un tipo de valor, pero si es un tipo de referencia, habrá problemas. Ver el siguiente ejemplo

 función persona () {}; persona.prototype.age = 10; persona.prototype.array = [1,2,3]; var p1 = new Person (); var p2 = new Person (); console.log (p1.array); // [1,2,3] console.log (p2.array); //Ija1,2,3font>p1.array.push(4);console.log(p1.array) ;//§,2,3,4font>console.log(p2.array) ;//§,2,3,4]

P1 agrega un valor a la matriz, que también se refleja en P2 porque todos apuntan a la misma matriz

4. Combinando el modo del constructor y el modo prototipo

Esta es la forma más común de crear objetos, combinando las ventajas de constructores y patrones de prototipo.

 Función Persona (nombre, edad) {this.name = name; this.age = edad;} persona.prototype.showmessage = function () {console.log ("nombre:"+this.name+"edad:"+this.age);}; var p1 = nueva persona ("k", 30); p1.showmessage ();

5. Modo de prototipo dinámico

La solución principal es: encapsular toda la información en el constructor, que está más en línea con la idea de OO

 Función Persona (nombre, edad) {this.name = name; this.age = edad; if (typeof this.showmessage! = "function") {persona.prototype.showmessage = function () {console.log ("nombre:"+this.name+"edad:"+this.age); }}} var p1 = nueva persona ("k", 30); p1.showMessage ();

6. Patrón de constructor parásito

 Función Persona (nombre, edad) {var o = nuevo objeto (); o.name = nombre; o.age = edad; o.sayname = function () {console.log (this.name); }; return o;} var p1 = nueva persona ("k", 28); p1.sayname ();

El patrón del constructor parásito es exactamente el mismo que el patrón de fábrica, excepto que la nueva palabra clave se usa al crear el objeto. El ejemplo anterior: var p1 = nueva persona ("k", 28).

Su función principal es: expandir las funciones en este constructor. Por ejemplo, quiero definir un tipo de matriz myArray, que se basa en una matriz de matriz y tiene su propio método, de la siguiente manera

 function myArray () {var valores = new array (); valores.push.apply (valores, argumentos); // El método definido por usted vale.TopipedString = function () {return this.Join ('|'); }; Valores de retorno;} var colores = new MyArray ("rojo", "azul", "verde"); console.log (colores.topipedString ()); console.log (Colors instanceOf array);

7. Modo de constructor estable

El constructor seguro sigue el patrón del tipo de constructor parásito, pero hay dos diferencias: una no es usar esto, y el otro no es usar nuevo para llamar al constructor.

 Función Persona (nombre, edad) {var o = nuevo objeto (); Var tempage = edad; o.name = nombre; o.age = edad; O.SayName = function () {console.log (nombre); } o.sayage = function () {console.log (tempage); } return o;} var p1 = persona ("k1", 28); p1.sayname (); // k1p1.sayage (); // 28p1.name = "k2"; p1.age = 30; p1.sayname (); // k1p1.sayage (); // 28

Cuando vea la salida anterior, puede entender qué es un patrón de objeto seguro. Es un objeto creado usando este modo. No hay otra forma de cambiar el valor pasado durante la inicialización. Esta es persona ("K1", 28). Tal objeto es un objeto seguro. De hecho, es un cierre de JavaScript.

El breve análisis anterior del método para crear un objeto JavaScript es todo el contenido que comparto con usted. Espero que pueda darle una referencia y espero que pueda apoyar más a Wulin.com.