Este artículo resume el uso de JavaScript sobre la herencia. Compártelo para su referencia. Los detalles son los siguientes:
ejemplo:
Copie el código de la siguiente manera:/**
* Las subclases de implementación heredan la clase principal, pero no generan propiedades y métodos innecesarios
* @returns {function}
*/
Define (function () {
Función de retorno (Subtype, Supertype) {
var proto = nuevo objeto (supertype.prototype);
proto.constructor = subtype;
subtype.prototype = proto;
};
});
// "..... ... ...
Define (function () {
Ostrucción (s) de función de la función
{
this.str = s;
this.length = this.str.length;
}
Ostring.prototype.show = function () {
alerta (this.str);
};
devolver el ostring;
});
// "..... ... ...
Define (['heredero', 'ostring'], function (heredero, ostring) {
función wstring (s) {
// Use la llamada al constructor de la clase principal
ostring.call (this, s);
this.chlength = 2 * s.length;
}
// heredar otros atributos
heredar (wstring, ostring);
wstring.prototype.add = function (w)
{
alerta (this.str + w);
};
devolver wstring;
});
Mira el ejemplo de nuevo
1. Use la función para implementar:
Copie el código de la siguiente manera: Function Person (nombre) {
this.name = name;
}
Persona.prototype.getName = function () {
devolver esto.name;
}
Función Autor (nombre, libros) {
this.inherit = persona;
this.inherit (nombre);
this.books = libros;
}
var au = nuevo autor ("dororo", "aprender mucho");
au.name
O equivalente:
Copie el código de la siguiente manera: Function Person (nombre) {
this.name = name;
}
Persona.prototype.getName = function () {
devolver esto.name;
}
Función Autor (nombre, libros) {
Persona.call (esto, nombre);
this.books = libros;
}
var au = nuevo autor ("dororo", "aprender mucho");
au.getName
Dado que esto solo está tomando esto como un parámetro, llamando al constructor de la persona de la clase principal y asignando todos los dominios asignados a la clase principal a la subclase del autor, cualquier dominio definido fuera del constructor de la persona de la clase principal no será heredado. Entonces, en el ejemplo anterior, Au.getName no se definirá (indefinido) porque GetName se define en el objeto prototipo de persona.
Además, el constructor de una subclase debe llamar al constructor de la clase principal antes de definir su propio dominio, para no sobrescribir la definición de la subclase por parte de la clase principal. En otras palabras, el autor define el libro de propiedad tras persona. Al mismo tiempo, es mejor no usar el prototipo para definir el dominio de la función de la subclase en subclases, porque después de que una subclase sea nueva e instanciada, el prototipo debe ejecutarse, y luego se llama al constructor de la clase principal, lo cual también es fácil de escribir por los atributos de la clase principal.
2. Use el prototipo para implementar:
Copie el código de la siguiente manera: Function Person (nombre) {
this.name = name;
}
Persona.prototype.getName = function () {
devolver esto.name;
}
Función Autor (nombre, libros) {
this.books = libros;
}
Autor.prototype = nueva persona (nombre);
Autor.prototype.constructor = autor;
Autor.prototype.getBooks = function () {
devolver esto.books;
}
var au1 = nuevo autor ("dororo1", "aprender mucho");
var au2 = nuevo autor ("dororo2", "aprender menos");
alerta (au1.getName ());
alerta (au2.getName ());
Este método evita el problema de que el prototipo no puede ser heredado en la implementación de funciones. Porque autor.prototype = nueva persona (nombre); nueva instancia de persona () llamará a todas las propiedades de la construcción y prototipo de la persona. Pero la desventaja es que el autor. Prototype ha sido instanciado. Entonces, cuando se instancian las subclases, todos los tipos de datos no base son copias de referencia. Entonces, en el ejemplo anterior, el valor devuelto por el ejemplo AU1 o AU2 es Dororo1.
3. Use "híbrido" para lograr
Copie el código de la siguiente manera: Function Person (nombre) {
this.name = name;
}
Persona.prototype.getName = function () {
devolver esto.name;
}
Función Autor (nombre, libros) {
this.base = nueva persona (nombre);
para (var key var en this.base) {
if (! this [key]) {
esta [clave] = this.base [clave];
}
}
this.book = libros;
}
var au1 = nuevo autor ("dororo1", "trabajo");
var au2 = nuevo autor ("dororo2", "jugar");
alerta (au1.getName ());
alerta (au2.getName ());
au1.book;
au2.book;
Pertenece a una extensión, copie todos los dominios de la clase principal a una subclase. No hay problemas en los dos aspectos anteriores.
Modo de combinación parasitaria)
La herencia JS incluye la herencia de los atributos y la herencia de métodos, que se implementan a través de diferentes métodos.
1. Herencia de atributos
La herencia de los atributos se logra cambiando el entorno de ejecución de la función. El entorno de ejecución de cambiar la función se puede implementar utilizando dos métodos: callar () y aplicar ().
Primero creamos un animal "clase" (porque no hay concepto de una clase en JS, aquí hay solo un simulacro, en realidad es solo un objeto de función de función).
Copie el código de la siguiente manera: function animal (typename) {
// Agregar un nombre de tipo de propiedad para el entorno de ejecución del método actual (esto)
// pero el entorno de ejecución (esto) debe ejecutarse antes de que pueda determinarse
this.typename = typename;
this.colors = ["rojo", "while"];
}
// Quiero agregar dos métodos (objeto compartido) al prototipo de la función
Animal.prototype.shout = function () {alert ("I am: -" + this.typename);};
Animal.prototype.eat = function () {alert ("I am: -" + this.typename)};
//-Defina un león-"clase" (en realidad una función)
function lion (tn) {
//-ejecute el método animal y modifique el entorno de ejecución de animales a este león a través del primer parámetro de aplicar
// Del mismo modo, Lion's esto debe ejecutarse para determinar quién es
Animal.apply (this, ["león"]); //-hereda los atributos variables de la clase principal, esto se debe a que es un león nuevo, este es un león
}
Lion.prototype = animal.prototype; // heredar el método de la clase principal y hacerlo, pero esto no está bien escrito. Cuando la clase infantil agrega un método, la clase principal también tiene este método. Esta es una referencia de puntero
Lion.prototype.hunt = function () {
alerta ("Soy: Lion, quiero cazar ~~ ・ ~");
}
var aminm = new Animal ();
Aminm.hunt (); // --- puede acceder al método de subclase, que no es bueno
// ---- Entonces, ¿cómo resolver este problema? ? ? ? ? ?
// --- Solución: puede escribir esto al heredar el método:
Lion.prototype = new Animal (); // heredar el método de clase principal y asignar el objeto animal al prototipo prototipo. De hecho, también tiene atributos.
var lion = new Lion (); // Además de crear la nueva palabra clave, también modificará el entorno de ejecución del objeto Lion al propio objeto Lion
// --- En otras palabras, después de que se termine nuevo, esto en la función de león es la función de león en sí, y luego se llama la función de león
Analice las nuevas palabras clave:
La nueva palabra clave es muy buena. En el código anterior, la nueva palabra clave completa las siguientes tareas:
1) Abra espacio de montón para prepararse para almacenar objetos de león
2) Modifique el entorno de ejecución del objeto Lion en sí mismo para que esto de la función de león apunte al objeto de la función Lion.
3) Llame al "constructor" de la clase de león "y cree un objeto de león
4) Asigne la dirección de montón del objeto de función de león a la variable L, y en este momento l puntos al objeto de función de león
Lion.Shout ();
león.eat ();
Sin embargo, esta herencia tiene una desventaja: el constructor de la clase principal se llama dos veces, llame una vez y luego nuevamente.
Espero que este artículo sea útil para la programación de JavaScript de todos.