Antes de comenzar el código, debe comprender claramente el propósito de la herencia y qué beneficios pueden traer. En términos generales, al diseñar la clase, esperamos reducir el código duplicado y debilitar el acoplamiento entre clases. Es difícil cuidar ambos. Según nuestra comprensión de la herencia del lenguaje de la cara al objeto, la herencia traerá un acoplamiento directo fuerte, pero debido a su flexibilidad única, JS puede diseñar un acoplamiento fuerte y un código de acoplamiento débil, alta eficiencia y código ineficiente. Y lo que usa depende de la situación.
Lo siguiente proporciona tres métodos de herencia en JS: herencia de clase, herencia prototipo y mezcla. Aquí hay una breve descripción de la herencia de la clase.
Herencia de forma de clase.
La realización de la herencia del tipo JS depende de la cadena prototipo. ¿Cuál es la cadena original? El objeto en JS tiene un atributo Prototy.
Parece tener una impresión de prototipo.
Copiar código del código de la siguiente manera:
var persona = function () {
this.name = "liyatang";
};
Persona.prototype = {
// puede proporcionar la función básica de la persona aquí
getName: function () {
Devolver esto.name;
}
}
Ponemos la función básica de la clase en la propiedad prototipo, lo que indica que la referencia del objeto de la persona tiene la función XXX.
Después de comprender el prototipo, debe comprender cuál es la cadena original. Cuando un miembro (atributo o método) del objeto visitante, si el miembro no se ve en el objeto actual, entonces JS lo encontrará en el objeto mencionado en el atributo prototipo. Si no se encuentra, volverá a UndiFined.
Entonces, ¿qué indicaciones nos da la cadena original? Es fácil pensar que la cadena principal significa permitir que una clase herede otra clase. Esto une a los miembros de la clase principal a la subclass, porque encontrarán la clase principal cuando no se encuentren en la subclase. (Los dos párrafos de las palabras anteriores no son rigurosos, solo se describen en palabras fáciles de entender)
A continuación necesitamos una clase china, y necesitamos heredar los nombres y los miembros de GetName de la clase de la persona.
Copiar código del código de la siguiente manera:
Var chino = function (nombre, nación) {
// Herencia, debe llamar al constructor de la clase principal, puede llamarlo con llamadas, este punto al chino
// La persona puede llamar a los miembros de la persona en este alcance
Persona.call (esto, nombre);
this.nation = National;
};
Chino.prototype = persona.prototype;
// No es lo mismo que antes, porque el atributo prototipo está cubierto
//Chinese.prototype = {
// getNation: function () {{
// devolver esto.nation;
//}
//};
// La forma en el futuro deberá agregarse así
Chino.prototype.getNation = function () {
Devolver esto.nation;
};
Se establece la relación de herencia, la llamamos así
Copiar código del código de la siguiente manera:
var c = nuevo chino ("liyatang", "China");
alerta (c.getName ());
Entonces se completa la herencia del tipo. ¿Está realmente hecho?
Esto se debe a que el código anterior chino.prototype = persona.prototype; Esto no se tolera en sí mismo, y no es el efecto que queremos.
Podemos debilitar el acoplamiento en otro objeto o instancia.
Copiar código del código de la siguiente manera:
//
//Chinese.prototype = new Person ();
// el segundo tipo
// var f = function () {};
//F.prototype = persona.prototype;
//Chinese.prototype = f.prototype;
¿Cuáles son las diferencias entre estos dos métodos? Agregue una función vacía F en el segundo tipo, que puede evitar una instancia de la creación de una clase principal, porque la clase principal puede ser grande, y la función de la estructura de la clase principal tendrá algunos efectos secundarios o una gran cantidad de cálculos será realizado. Así que recomiendo el segundo método.
En este punto, ya no ha terminado! Hay un atributos de los atributos de los atributos del objeto, que conserva una referencia a una función de una instancia de objeto específica. Según esta declaración, chiese.prototype.constructor debe ser igual al chino, lo que en realidad no lo es.
Cuando se estableció la cadena prototipo de Chiese antes de los recuerdos, cubrimos la persona. Prototipo de chiese.prototype. Entonces, en este momento, chiese.prototype.constructor es persona. También necesitamos agregar el siguiente código
Copiar código del código de la siguiente manera:
// No hay necesidad de investigar las condiciones IF aquí, conociendo chino.prototype.constructor = chino
If (chino.prototype.constructor == object.prototype.constructor) {
Chino.prototype.constructor = chino;
}
Convertirse en todo el código de la siguiente manera
Copiar código del código de la siguiente manera:
var persona = function (nombre) {
this.name = name;
};
Persona.prototype = {
getName: function () {
Devolver esto.name;
}
};
Var chino = function (nombre, nación) {
Persona.call (esto, nombre);
this.nation = National;
};
var f = function () {};
F.prototype = persona.prototype;
Chino.prototype = f.prototype;
If (chino.prototype.constructor == object.prototype.constructor) {
Chino.prototype.constructor = chino;
}
Chino.prototype.getNation = function () {
Devolver esto.nation;
};
var c = nuevo chino ("liyatang", "China");
alerta (c.getName ());
Si puede colocar el código de herencia en una función, es conveniente que el código reutilice, y la última clasificación del código es el siguiente
Copiar código del código de la siguiente manera:
Function extend (subclass, superclase) {{
var f = function () {};
F.prototype = superclass.prototype;
subclass.prototype = new f ();
subclass.prototype.constructor = subclass;
subclass.superclass = superclass.prototype;
If (superclass.prototype.constructor == object.prototype.constructor) {
superclass.prototype.constructor = superclass;
}
}
var persona = function (nombre) {
this.name = name;
};
Persona.prototype = {
getName: function () {
Devolver esto.name;
}
};
Var chino = function (nombre, nación) {
Persona.call (esto, nombre);
this.nation = National;
};
extender (chino, persona);
Chino.prototype.getNation = function () {
Devolver esto.nation;
};
var c = nuevo chino ("liyatang", "China");
alerta (c.getName ());
Modificación después de la publicación:
Según los comentarios en el primer piso, tengo una nueva vista de esa función de extensión. Se propusieron dos métodos al discutir cómo establecer la cadena original.
Copiar código del código de la siguiente manera:
//
//Chinese.prototype = new Person ();
// el segundo tipo
// var f = function () {};
//F.prototype = persona.prototype;
//Chinese.prototype = f.prototype;
Aunque la segunda forma de reducir la función de construcción de la clase principal, la persona.
Sin embargo, en el primer método, puede reducir la persona. Puede desear poner este código de función en extensión. Solo escribe
Chino.prototype = nueva persona ();
Pero el olvido es que chino.prototype = new Person (); ¡La respuesta está mal! Obviamente, nueva persona () necesita pasar un parámetro de nombre. No podemos hacer esta parte de la función de extensión, por lo que tenemos que llamar al constructor de clase matriz en la clase china. Esto también está en línea con las ideas orientadas al objeto.
Por lo tanto, todavía se recomienda usar el segundo método.
La primera vez que escribí sobre artículos técnicos de esta manera, básicamente está pavimentado de acuerdo con mi propio pensamiento.