En JavaScript, podemos usar prototipos para lograr la herencia.
Por ejemplo
function baz () {this.oo = "";} function foo () {} foo.prototype = new Baz (); var myfoo = new foo (); myfoo.oo;De esta manera podemos acceder al atributo OO en Baz. Esto no es posible en el uso real, debido a las características de intercambio del prototipo (los datos se guarda en el montón),
Todas las instancias usan un prototipo, pero una vez que el atributo BAZ tiene un tipo de referencia, será trágico. Si se modifica una instancia, la otra instancia también cambiará ... Wuwuwu
Naturalmente habrá herencia combinada
function baz () {this.oo = "";} baz.prototype.xx = function () {} function foo () {baz.call (this); // la segunda llamada} foo.prototype = new Baz (); // La primera llamada var myfoo = new foo (); myfoo.xx;Esto tendrá un problema, y el código también muestra que Baz se llamará dos veces. ¿Cómo puede Virgo permitirlo?
Si agrega una oración, ¿no necesitará el segundo método tener el problema con el primer método? La respuesta es no.
La razón es que la búsqueda de atributos comienza con el objeto en sí. Solo cuando no se encuentre, se encontrará en el prototipo. Al llamar, los atributos se heredan.
Permítanme agregar otra oración, entonces ¿no será suficiente usar solo la herencia de llamadas como esta? Esto es factible si no usa un prototipo, pero ¿cómo no puede usar un prototipo como virgo?
El método se comparte en el prototipo, por lo que el rendimiento será mucho mejor.
Herencia de combinación parásita
__extends=function (p,c){function ctor(){this.constructor=c;//Assignment constructor}ctor.prototype=p.prototype;c.prototype=new ctor();}function baz(){this.oo=[1];}baz.prototype.xx=function(){}__extends(baz,foo);function foo () {baz.call (this);} var myfoo = new foo (); myfoo.oo; myfoo.xx;Esto no solo resuelve el problema de dos llamadas, sino que también resuelve el problema de que cuando el objeto llama al constructor, la función real que crea el objeto se llama en lugar de otros constructores en la cadena prototipo.
Hay una declaración en el código.
El constructor es un atributo en el objeto prototipo y es el creador del objeto. Dado que nuestros atributos prototipo se reasignan, el constructor se hereda.
Aquí quiero hablar sobre cómo se crean los objetos, es decir, qué ha hecho.
Por ejemplo:
var a = nuevo b ();
En realidad, es así, a = {}; crea A para a, y luego b.call (a); Llamar inicializa a. Hay otro paso antes de la llamada, que es el objeto prototipo interno de a.
El objeto prototipo al que la propiedad Prototype establece en B puntos. Hay un atributo de constructor en el prototipo, que se utiliza para crear controles de memoria de asignación de objetos.
Probablemente sea todo ... todavía es tarde, vamos a romperlo. Mantenga una mente tranquila y no seas impaciente. Trabaje duro para cambiar mañana y espero que todo mejore gradualmente.
Lo anterior es todo el contenido que el editor le brinda sobre la comprensión integral de la herencia (debe leer) en JavaScript. Espero que todos apoyen más a los pasos a casa.