Una breve discusión sobre los tres métodos de herencia y sus ventajas y desventajas en JS

El primer método de prototipo:

 // Función de clase Presidente Persona () {this.hair = 'Black'; this.eye = 'negro'; this.skin = 'amarillo'; this.view = function () {return this.hair + ',' + this.eye + ',' + this.skin; }} // Subclase Function Man () {this.feature = ['Beard', 'Strong']; } man.prototype = new Person (); var uno = nuevo hombre (); console.log (One.Feature); // ['Beard', 'Strong'] Console.log (One.hair); // Black Console.log (One.eye); // Black Console.log (One.skin); // Yellow Console.log (One.view ()); // negro, negro, amarillo

Este método es el más simple. Solo necesita asignar el valor de atributo prototipo de la subclase a una instancia hereditaria, y luego puede usar directamente el método de clase heredado.

¿Qué significa el atributo prototipo? El prototipo es el prototipo. Cada objeto (definido por función) tiene una propiedad prototipo predeterminada, que es un tipo de objeto.

Y este atributo predeterminado se utiliza para implementar la verificación de la cadena de ventaja. Esto significa que si el atributo de un objeto no existe, el atributo se encontrará a través del objeto al que pertenece el prototipo del atributo. ¿Qué pasa si no se puede encontrar el prototipo?

JS encontrará automáticamente el objeto al que pertenece la propiedad prototipo al atributo prototipo, de modo que continúe indexando a través del prototipo hasta que la propiedad o el prototipo se encuentren y finalmente vacíe ("indefinido");

Por ejemplo, en el método One.view () En el ejemplo anterior, JS primero buscará si hay un método View () en una instancia. Debido a que no hay, busca el atributo Man.Prototype, y el valor del prototipo es una instancia de persona.

Esta instancia tiene un método View (), por lo que la llamada es exitosa.

La segunda forma es aplicar:

 // Función de clase Presidente Persona () {this.hair = 'Black'; this.eye = 'negro'; this.skin = 'amarillo'; this.view = function () {return this.hair + ',' + this.eye + ',' + this.skin; }} // Subclase Function Man () {// Person.apply (this, new Array ()); persona.apply (esto, []); this.Feature = ['Beard', 'Strong']; } var One = new Man (); console.log (One.Feature); // ['Beard', 'Strong'] Console.log (One.hair); // Black Console.log (One.eye); // Black Console.log (One.skin); // Yellow Console.log (One.view ()); // negro, negro, amarillo

Nota: Si el parámetro de aplicación está vacío, es decir, no se pasa ningún parámetro, se pasará a través de una nueva matriz () y [], y NULL no es válido.

El tercer tipo es Call+Prototype:

 // Función de clase Presidente Persona () {this.hair = 'Black'; this.eye = 'negro'; this.skin = 'amarillo'; this.view = function () {return this.hair + ',' + this.eye + ',' + this.skin; }} // Subclase Function Man () {// Person.apply (this, new Array ()); persona.call (this, []); this.Feature = ['Beard', 'Strong']; } man.prototype = new Person (); var uno = nuevo hombre (); console.log (One.Feature); // ['Beard', 'Strong'] Console.log (One.hair); // Black Console.log (One.eye); // Black Console.log (One.skin); // Yellow Console.log (One.view ()); // negro, negro, amarillo

El mecanismo de implementación del método de llamada requiere un hombre más.prototype = new Person (); ¿Por qué?

Esto se debe a que el método de llamada solo implementa el reemplazo del método y no copia los atributos del objeto.

Así es como hereda la API de Google Map.

Lo anterior resume la implementación de tres métodos de herencia. Pero cada método tiene sus ventajas y desventajas.

Si la clase principal es así:

 // La persona de la clase principal de la clase (cabello, ojo, piel) {this.hair = cabello; this.eye = ojo; this.skin = skin; this.view = function () {return this.hair + ',' + this.eye + ',' + this.skin; }}

¿Cómo se deben diseñar subclases para que la subclase Man pase los parámetros a la persona de la clase principal mientras crea objetos? El método de herencia de prototipo no es aplicable.

Debe usar el método de aplicar o llamar:

 // Aplicar método // subclase Function Man (cabello, ojo, piel) {persona.apply (this, [cabello, ojo, piel]); this.Feature = ['Beard', 'Strong']; } // Método de llamada // Subclase Function Man (cabello, ojo, piel) {Person.call (esto, cabello, ojo, piel); this.Feature = ['Beard', 'Strong']; }

Pero todavía hay desventajas para usar el método Aplicar. ¿Por qué? En JS, tenemos un operador muy importante, que es "instancia", que se utiliza para comparar si una cierta dirección opuesta es de cierto tipo.

Para este ejemplo, además de ser un tipo de hombre, una instancia también debe ser un tipo de persona. Sin embargo, después de heredar el método de aplicación, uno no pertenece al tipo de persona, es decir, el valor de (una instancia de persona) es falso.

Después de todo esto, la mejor manera de heredar es el método Call+Prototype. Después de eso, puede intentar si el valor de (una instancia de BasecLass) es cierto.

El tercer método de herencia también tiene defectos: al subclasificar los objetos nuevos, debe pasar los parámetros requeridos por la clase principal, y se reproducirán las propiedades y métodos en la clase principal. El siguiente método de herencia es perfecto:

 Función Persona (nombre) {this.name = name; } Persona.prototype.getName = function () {return this.name; } función china (nombre, nación) {persona.call (this, nombre); this.nation = nación; } // Hereding Method Función HereT (Subclass, SuperClass) {function f () {} f.prototype = superclass.prototype; subclass.prototype = new f (); subclass.prototype.constructor = subclass.constructor; } heredar (chino, persona); Chino.prototype.getNation = function () {return this.nation; }; var p = nueva persona ('shijun'); var c = nuevo chino ("liyatang", "China"); console.log (p); // persona {nombre: "shijun", getName: function} console.log (c); // chino {nombre: "liyatang", nación: "China", constructor: function, getnation: function, getName: function} console.log (P.Constructor); // Función Persona (nombre) {} console.log (C.Constructor); // function chino () {} console.log (c instancia de chino); // True Console.log (C instancia de persona); // verdadero

El artículo anterior discute brevemente los tres métodos de herencia y sus ventajas y desventajas en JS. Este es todo el contenido que comparto con ustedes. Espero que pueda darle una referencia y espero que pueda apoyar más a Wulin.com.