5. Herencia parásita
Similar a los constructores parásitos y los patrones de fábrica, cree una función que solo se use para encapsular el proceso de herencia, que mejora internamente el objeto de alguna manera y finalmente devuelve el objeto.
function createEnother (original) {var clone = object.create (original); // Cree un nuevo objeto llamando a la función clone.sayhi = function () {// Mejora este objeto de alguna manera alerta ("HI"); }; clon de regreso; // Devuelve este objeto} var persona = {nombre: "bob", amigos: ["shelby", "corte", "furgoneta"]}; var otro porterson = createAther (persona); otra persona.sayhi ();En el ejemplo anterior, la función createAnother recibe un parámetro, es decir, el objeto que se utilizará como base del nuevo objeto.
Otra persona es un nuevo objeto creado basado en la persona. El nuevo objeto no solo tiene todas las propiedades y métodos de persona, sino también su propio método sayhi ().
6. Herencia de combinación parásita
La herencia combinada es el patrón de herencia más utilizado en JS. El mayor problema con la herencia de combinación es que el constructor se llamará dos veces en cualquier caso: una vez al crear un prototipo de subtipo y la otra vez dentro del constructor subtipo.
function supertype (nombre) {this.name = name; this.colors = ["rojo", "azul", "verde"];} supertype.prototype.sayname = function () {alert (this.name);} function subtype (nombre, edad) {supertype.call (this, nombre); // La segunda llamada a supertype () this.age = edad;} subtype.prototype = new SuperType (); // La primera llamada a supertype () subtype.prototype.sayage = function () {alert (this.age);}Cuando el constructor supertipo se solicita por primera vez, subtype.prototype obtendrá dos propiedades: nombre y colores; Ambos son propiedades de instancias de Supertype, pero ahora se encuentran en el prototipo de subtipo.
Cuando se llama al constructor de subtipo, se llama nuevamente el constructor Supertype, y esta vez, el nombre y los colores del atributo de instancia se crean en el nuevo objeto.
Entonces, estos dos atributos bloquean dos atributos del mismo nombre en el prototipo.
La herencia de combinación parasitaria es resolver este problema.
Heredar atributos por constructores de préstamos;
Heredar el método a través de la cadena prototipo.
No es necesario llamar al constructor Supertype para especificar el prototipo del subtipo.
function hereitprototype (subtype, supertype) {var prototype = object.create (supertype.prototype); // Crear objeto prototipo.constructor = subtype; // mejorar el objeto subtype.prototype = prototipo; // especificar objeto} function supertype (name) {this.name = name; this.colors = ["rojo", "azul", "verde"];} supertype.prototype.sayname = function () {alert (this.name);} function subtype (nombre, edad) {supertype.call (this, nombre); // La segunda llamada a supertype () this.age = age;} HereTPrototype (subtype, supertype) subtype.prototype.sayage = function () {alert (this.age);} var instancia = nuevo subtype ("bob", 18); instancia.sayname (); instancia.sayage ();La función HerititPrototype recibe dos parámetros: el constructor de subtipo y el constructor supertipo.
1. Cree una copia del prototipo SuperType.
2. Agregue el atributo de constructor a la copia creada para compensar el atributo de constructor predeterminado perdido debido a la reescritura del prototipo.
3. Asigne el objeto recién creado (es decir, copia) al prototipo del subtipo. Este método solo llama al constructor Supertype una vez, e instanciaf e isprototypeOf () también se puede usar normalmente.
El artículo anterior habla brevemente sobre JS Heritance_Parasitic Heritance & Parasitic Combination Heritance es todo el contenido que comparto con ustedes. Espero que pueda darle una referencia y espero que pueda apoyar más a Wulin.com.