Como un lenguaje orientado a objetos (JS está basado en objetos), es esencial implementar la herencia, pero dado que no existe un concepto de clase en sí, no implementará la herencia a través de clases como un lenguaje de programación orientado a objetos real, pero puede implementar la herencia a través de otros métodos. Hay muchas formas de implementar la herencia, y las siguientes son solo algunas de ellas.
1. Herencia de la cadena prototipo
función persona () {// La función heredada se llama supertype (clase principal, clase base) this.name = 'mumu'; this.age = '18 '; } Persona.prototype.name = 'Susu'; // Cuando el nombre del atributo es el mismo, debe ser más cercano, busque en la instancia primero, pero luego vaya al prototipo para encontrar funciones trabajador () {// La función heredada se llama subtipo (subclase, clase derivada) this.job = 'estudiante'; } Trabajador.prototype = new Person (); // heredado a través de la cadena prototipo, la instancia de objeto instanciada por el supertipo se asigna al atributo prototipo de la subclase var p2 = new Worker (); console.log (p2.name); console.log (P2 instancef objeto); // ture Todos los constructores se heredan desde el objetoLa clave para implementar la herencia anterior es: Worker.Prototype = New Person (); Haga del prototipo del trabajador una instancia de persona y la herede a través de la cadena prototipo.
Nota: Cuando se utiliza cadenas prototipo para implementar la herencia, no puede usar literales de objetos para crear métodos prototipo, porque esto interrumpirá la relación y reescribirá la cadena prototipo.
Problema de herencia de la cadena prototipo:
1. Hay un problema de intercambio de referencia, y aún comparten el mismo espacio, y la subclase afectará a la clase principal.
function persona () {this.bodys = ['ojo', 'pie']; } function Worker () {} Worker.prototype = new Person (); var p1 = new Worker (); p1.bodys.push ('Hand'); var p2 = new Worker (); console.log (p1.bodys); console.log (p2.bodys);2. Al crear instancias de subtipos, los parámetros no se pueden pasar en constructores supertipo.
Entonces, ¿cómo resolver los dos problemas de la cadena prototipo? Luego continúe mirando el método de herencia a continuación ~
2. Herencia del constructor de préstamo (también llamado suplantación de objeto, objeto forjado o herencia clásica)
Función Persona (nombre, edad) {this.name = name; this.age = edad; this.bodys = ['Eye', 'Foot']; } Persona.prototype.showname = function () {console.log (this.name); } function worker (nombre, edad, trabajo) {persona.call (this, nombre, edad); this.job = Job; // subclase Agregar atributos} var p1 = new Worker ('Mumu', '18', 'estudiante'); p1.bodys.push ('Hand'); var p2 = new Worker (); console.log (p1.name); console.log (p2.bodys); console.log (p1.showname ());Un breve análisis del principio anterior del uso de constructores prestados: persona. Este código llama al constructor principal, hereda el atributo principal y usa el método de llamada para llamar al constructor de la persona para cambiar esto cuando se ejecuta la función. Aquí, esto-> nuevo es un método disfrazado de constructor de objetos de trabajadores: pase al trabajador a la persona anterior.
Cuando el tipo de referencia se coloca en el constructor, no se compartirá, por lo que P2 no se ve afectado.
Tomar prestado el método de herencia del constructor aquí resuelve el problema de que la cadena prototipo no puede pasar parámetros y compartir tipos de referencia.
Consejos: los métodos de llamada () y aplicar () pueden cambiar el alcance de la ejecución de la función, en resumen, cambiar el contenido señalado por esta función.
Tanto llamar () como aplicar () Aceptar dos parámetros: el primero es el alcance de la función que se ejecuta en ella, y el otro es el parámetro aprobado.
La diferencia entre llamar y aplicar es la diferencia en los parámetros.
Los parámetros en la llamada deben enumerarse uno por uno.
Los parámetros en aplicar deben ser objetos de matrices o argumentos
Entonces, la pregunta es: ¿por qué el resultado de P1.showname () está equivocado? ---- porque el método de herencia de los constructores de préstamo solo puede heredar atributos y métodos en el constructor. Aquí también encontramos un problema de los constructores de préstamos.
Nota: Dado que ponemos todos los métodos en el constructor, cada vez que instanciamos, asignaremos el espacio de memoria para desperdiciar recursos, por lo que generalmente ponemos métodos en el prototipo y los atributos en el constructor.
Problema de herencia del constructor de préstamo:
Debido a que tomar prestado un constructor solo puede heredar las propiedades y métodos en el constructor, los métodos definidos en el prototipo Supertype son invisibles para la subclase, por lo que es equivalente a no tener un prototipo. Como resultado, todos los métodos solo se pueden definir en el constructor, por lo que no hay multiplexación por función.
Entonces, ¿cómo resolver el problema causado por los constructores de préstamos? Entonces depende del siguiente método de herencia
3. Herencia combinada (herencia pseudo-clásica)
Función Persona (nombre, edad) {this.name = name; this.age = edad; } Persona.prototype.showname = function () {console.log (this.name); } function Worker (nombre, edad, trabajo) {persona.call (this, nombre, edad); // préstamos constructor this.job = trabajo; } Trabajador.prototype = new Person (); // herencia de cadena prototipo var p1 = nuevo trabajador ('mumu', '18', 'estudiante'); console.log (p1.age); p1.showname ();Herencia de combinación: combinando la cadena prototipo con el constructor prestado.
Idea: mediante el uso de la cadena prototipo para implementar la herencia de atributos y métodos en el prototipo, y al tomar prestado el constructor para implementar la herencia de los atributos de instancia
La persona de ejemplo anterior. CALL (este, nombre, edad); Presta el constructor para heredar los atributos
Worker.prototype = New Person (); la cadena prototipo hereda el método, evita las deficiencias de los dos, combina sus ventajas y se convierte en el modelo de herencia más utilizado.
Problemas de herencia de combinación:
El constructor Supertype se llama dos veces, una vez al crear un prototipo de subtipo y la otra vez dentro del constructor de subtipo.
Para resolver este problema, debemos usar la herencia de combinación parásita.
4. Prototipo de herencia
objeto de función (proto) {function f () {} f.prototype = proto; devolver nuevo f (); } var persona = {nombre: 'Mumu', Friends: ['Xiaxia', 'Susu']}; var otroperson = objeto (persona); otroperson.friends.push ('wen'); var y thitanotherperson = objeto (persona); otroperson.friends.push ('Tian'); console.log (Person.friends); // ["Xiaxia", "Susu", "Wen", "Tian"] Console.log (Otroperson .__ Proto __) // Object {Nombre: "Mumu", Friends: Array [4]}Un breve análisis: el objeto de función (proto) es una función de relé temporal, el parámetro proto en él representa un objeto que se transmite. El constructor f () es un objeto temporal recién creado, que se utiliza para almacenar el objeto pasado. F.Prototype = Proto; Asigne la instancia del objeto al objeto prototipo del constructor F y finalmente devuelva la instancia del objeto del objeto aprobado. Prototipo de herencia o compartir atributos de tipos de referencia.
5. Herencia parásita
// objeto de función de tránsito temporal (proto) {function f () {} f.prototype = proto; devolver nuevo f (); } // función de parásito create (proto) {var f = object (proto); f.love = function () {return this.name; } return f; } var persona = {nombre: 'Mumu', Friends: ['Xiaxia', 'Susu']}; var otroperson = create (persona); console.log (otroperson.love ()); Herencia de combinación parásita6. Herencia de combinación parásita
objeto de función (proto) {function f () {} f.prototype = proto; devolver nuevo f (); } // función de la función de parásito create (persona, trabajador) {var f = object (persona.prototype); // Crear objeto f.constructor = trabajador; // Ajuste el puntero de la construcción prototipo y mejore el objeto trabajador.prototype = f; // especifique la persona de la función de objeto} (nombre, edad) {this.name = name; this.age = edad; } Persona.prototype.showname = function () {console.log (this.name); } function worker (nombre, edad, trabajo) {persona.call (this, nombre, edad); this.job = trabajo; } create (persona, trabajador); // herencia combinada de parásito var p1 = nueva persona ('mumu', '18', 'estudiante'); p1.showname ();Este método también es la forma más perfecta e ideal de implementar métodos de herencia ahora.
Las notas de aprendizaje de herencia de JavaScript anteriores [deben leer para principiantes] es todo el contenido compartido por el editor. Espero que pueda darle una referencia y espero que pueda apoyar más a Wulin.com.