La herencia basada en la cadena de prototipo de JavaScript

JavaScript no es un lenguaje orientado a objetos y no proporciona métodos de herencia tradicionales, pero proporciona una forma de herencia prototipo, utilizando las propiedades prototipo que proporciona para lograr la herencia.

La cadena prototipo es el método principal de herencia en JavaScript.

La idea básica de la cadena prototipo es: usar prototipos para permitir que un tipo de referencia herede las propiedades y métodos de otro tipo de referencia.

Relación entre constructores, prototipos e instancias: cada constructor tiene un objeto prototipo, el objeto prototipo contiene un puntero al constructor, y la instancia contiene un puntero interno al objeto prototipo.

Si el objeto prototipo es igual a una instancia de otro objeto, el objeto prototipo contendrá un puntero a otro prototipo y, en consecuencia, el otro prototipo también contiene un puntero a otro constructor.

Modo básico de implementación de la cadena de prototipos:

 function supertype () {this.property = true;} supertype.prototype.getsuperValue = function () {return this.property;}; function subtype () {this.subproperty = false;} // inhereT SuperTypesSubtype.prototype = new supertype (); subtype.portotype.pototype.pototype.pototype.pototype. () {return this.subproperty;}; var instance = new Subtype (); alert (instance.getSuperValue ()); // verdadero

El subtipo hereda Supertype, que se logra creando una instancia de Supertype y asignando la instancia a Subtype.Prototype. La esencia de la implementación es reescribir el objeto prototipo y reemplazarlo con una instancia de un nuevo tipo. De esta manera, las propiedades y métodos que existen originalmente en la instancia de Supertype también existen en Subtype.Prototype. Luego agregue un método a subtype.prototype, que agrega otro método basado en heredar las propiedades y métodos de supertipo.

La relación de instancia en el ejemplo anterior se expresa de la siguiente manera:

Lo anterior no utiliza el prototipo proporcionado por el subtipo por defecto, sino que lo reemplaza con un nuevo prototipo; Este nuevo prototipo es una instancia de supertipo. También hay un puntero al prototipo que ejecuta Supertype dentro del nuevo prototipo. Como resultado, la instancia apunta al prototipo de subtipo, que apunta al prototipo de supertipo. El método getValue () todavía está en supertipo.prototype, pero el prototipo está en subtipo.prototype. Esto se debe a que la propiedad es una propiedad de instancia, y GetuPerValue () es un método prototipo. Dado que subtype.prototype es ahora una instancia de supertipo, la propiedad está naturalmente ubicada en ese caso.

NOTA: instancia. El -Constructor ahora apunta a Supertype, porque el prototipo de subtipo apunta a otro objeto: el prototipo de Supertype y el atributo constructor de este prototipo de objeto apunta a Supertype.

Al acceder a un atributo en modo de lectura, la instancia primero se busca ese atributo. Si no se encuentra la propiedad. Luego continuará la búsqueda del prototipo de la instancia. Cuando se logra la herencia a través de la cadena prototipo, el proceso de búsqueda puede continuar avanzando hacia arriba a lo largo de la cadena prototipo.

Prototipo predeterminado

Todos los tipos de referencia heredan el objeto de forma predeterminada, y esta herencia también se implementa a través de la cadena prototipo. El prototipo predeterminado de todas las funciones es una instancia de objeto. Por lo tanto, el prototipo predeterminado contendrá un puntero interno a Object.Prototype. Esta es la razón por la cual los tipos personalizados heredarán métodos como toString (), valueOf (), etc.

Cadena de prototipo completo:

En el sistema de herencia anterior, el subtipo hereda el supertipo, y el supertipo hereda el objeto. Cuando se llama a instancia.toString (), el método guardado en Object.prototype realmente se llama.

Determinar la relación entre instancia y prototipo

Hay dos formas de determinar la relación entre un prototipo y una instancia:

Use el operador de instancia de

 alerta (instancia instancia de objeto); alerta (instancia instancia de supertipo); alerta (instancia instancia de subtipo);

Debido a la relación entre la cadena prototipo, todos los anteriores regresan verdaderos.

Usar el método isprototypeOf ()

 alerta (objeto.prototype.isPrototypeOf (instancia)); alerta (supertype.prototype.isPrototypeOf (instancia)); alerta (subtype.prototype.isprototypeOf (instancia)); alerta (subtype.prototype.isprototypeOf (instancia));

Defina el método con cuidado

El código para agregar métodos al prototipo debe colocarse después de la declaración que reemplaza el prototipo.

 function supertype () {this.property = true;} supertype.protype.getsuperValue = function () {return this.property;}; function subtype () {this.subproperty = false;} supertype.prototype = neweType (); // add método subtype.prototype.getsgetswetsgets (function = niew = new) this.subProperty;}; // Sobrescribe el método subtype.prototype.getSuperValue = function () {return this.subproperty;}; // Overwrite el método subtype.prototype.getsuperValue = function () {return false;}; var instance = new Subtype (); alerta (instancia (instancia (instancia Insciete // FALSO

En el ejemplo anterior, debe tenerse en cuenta que después de reemplazar el prototipo con la instancia de supertipo, luego definir esos dos métodos.

Además, al heredar a través de la cadena prototipo, no puede usar el objeto literal para crear un método prototipo. Porque hacerlo reescribirá la cadena prototipo:

 function supertype () {this.property = true;} supertype.prototype.getsuperValue = function () {return this.property;}; function subtype () {this.subproperty = false;} // SUPERTyPesubType.Prototype = new SuperType (); // New Method, que usa el código de código anterior, lo que ocurre con el código anterior, lo que ocurre en el código anterior, lo que ocurre en el código de código anterior. inválido subtype.prototype = {getSubValue: function () {return this.subproperty;}, SomeTherMethod: function () {return false;}}; var instance = new Subtype (); alert (instancia.getSupervalue ()); // error

El ejemplo anterior asigna la instancia de SuperType al prototipo, y luego reemplaza el prototipo con un objeto literal. El prototipo actual contiene una instancia de objeto, no una instancia de supertipo, y no hay relación entre el subtipo y el supertipo.

Problema de la cadena prototipo

Como se mencionó anteriormente, los atributos prototipo que contienen tipos de referencia son compartidos por todas las instancias; Esta es la razón por la cual los atributos deben definirse en el constructor en lugar de en el objeto prototipo.

 function supertype () {this.colors = ["rojo", "azul", "verde"];} function subtype () {} subtype.prototype = new supertype (); var instance1 = new Subtype (); instancia1.colors.push ("negro"); alerta (instancia1.colors); // "rojo", "azul", "verde", "negro" var instance2 = new subtype (); alerta (instancia2.colors); // "rojo", "azul", "verde", "negro"

En el ejemplo anterior, una propiedad de colores se define en el constructor Supertype, que contiene una matriz, y cada instancia de SuperType tendrá una propiedad de colores que contiene su propia matriz. Después de que el subtipo hereda Supertype a través de la cadena prototipo, Subtype.prototype se convierte en una instancia de supertipo, por lo que también tiene su propio atributo de colores. Sin embargo, todas las instancias de subtipo comparten esta propiedad de colores.

Otro problema es que no hay forma de pasar los parámetros al constructor de superclase sin afectar todas las instancias de objetos.

Lo anterior es el conocimiento relevante de JavaScript basado en la herencia de la cadena prototipo que el editor le presentó. Espero que te sea útil. Si tiene alguna pregunta, déjame un mensaje y el editor le responderá a tiempo. ¡Muchas gracias por su apoyo al sitio web de Wulin.com!