Análisis de prototipo en JavaScript [recomendado]

Recientemente, cuando estaba aprendiendo JavaScript y aprendiendo el prototipo de JS orientado a objetos, tengo muchas ideas. Si hay algo mal, espero que pueda corregirse.

Como un lenguaje orientado a objetos, JS naturalmente tiene el concepto de herencia, pero no hay concepto de clases en JS, por lo que no se extiende similares a las de Java. Por lo tanto, creo que la herencia en JS depende principalmente de prototipos (cadenas) en JS.

Entonces, ¿cuál es el prototipo? Sabemos que las funciones en JS también son un objeto. Cuando creamos una función, la función en realidad tiene una propiedad llamada prototipo. Este tipo de género se llama propiedad prototipo. Es un puntero que apunta al objeto prototipo de esta función. Este objeto prototipo tiene una propiedad predeterminada llamada constructor. Este tipo de género apunta a una función que tiene un tipo de prototipo.

 function persona () {} persona.prototype = {// constructor: persona; First_Name: "Guo", Hair_Color: "Black", City: "Zhengzhou", Act: Function () {Alert ("Eating");}};

Tomando esto como ejemplo, primero creamos una persona de funciones. Esta función tiene un prototipo de atributo predeterminado, apuntando al objeto Person.ProptType. Este objeto tiene un atributo predeterminado constructor (), persona.prototype.constructor ---> persona. (De hecho, el valor predeterminado aquí es apuntar al objeto, y la corrección se realizará más adelante)

¿Qué sucede cuando creamos una instancia a través de un constructor?

 function Person () {} Person.prototype = {First_Name: "Guo", Hair_Color: "Black", City: "Zhengzhou", Act: Function () {Alert ("Eating");}}; var boy = nueva persona (); var niña = nueva persona ();

En este momento, necesitamos saber que la diferencia entre un constructor y una función en JS es la nueva palabra clave, y una función que utiliza el nuevo operador es un constructor. Cuando creamos el objeto de instancia de la persona y lo guardamos en Boy, Girl, estos dos objetos de instancia generarán un atributo predeterminado llamado _proto_ (que puede representarse por [[prototipo]] en ECMAScript5). Este tipo de género apunta al objeto prototipo del constructor, es decir, boy._proto _ ---> persona.prototype (no tiene nada que ver con el constructor). En este momento, el niño o la niña pueden usar puntos para llamar al tipo de género en el objeto prototipo. En este momento, debes saber que el niño y la niña comparten el tipo de género del objeto prototipo. Podemos verificar la conclusión anterior por isProtpTypeOf () u Object.getProTotypeOf () (el valor de retorno de esta función es el objeto prototipo, es decir, el valor de _proto_).

 alerta (persona.prototype.isprototypeOf (boy)); // true alerta (object.getPrototypeOf (boy) .first_name); // "Guo"

En este momento, podemos hacer una verificación adicional. ¿Qué pasa si creamos un atributo duplicado con el atributo de objeto prototipo en la instancia?

 var boy = nueva persona (); var niña = nueva persona (); boy.hair_color = "rojo"; alerta (boy.hair_color); // alerta roja (niña.hair_color); // alerta negra (object.getPrototypeOf (boy) .hair_color); //negro

Se puede ver que el atributo duplicado declarado en la instancia bloqueará las propiedades en el objeto prototipo, pero solo se sobrescribirá y no afectará el tipo de género del objeto prototipo (objeto.getPrototypeOf (boy) .Hair_color == Black), ni afectará los objetos de instancia que comparten el tipo de género del prototipo del objeto (girl.hair_color == Black), ni afectará los objetos de instancia que comparten el tipo de género del objeto Prototype (girl.hair_color == Black). Al mismo tiempo, puede usar el operador Eliminar para eliminar los atributos declarados por el objeto de instancia para deshacer el efecto de enmascaramiento. Podemos usar aSownProperty () para verificar si existe un género en una instancia (verdadera) o en un objeto prototipo (falso).

 alerta (boy.hasownproperty ("peinado_color")); //verdadero

Puede usar Object.Keys () para enumerar las propiedades.

 var key = object.keys (persona.prototype); alerta (clave);

Después de aprenderlos, encontraremos que utilizando el método de escritura anterior para declarar un objeto prototipo, habrá un problema. El constructor ya no apunta a la persona, lo que es contrario al valor predeterminado que apunta a una función que contiene el atributo prototipo. Esto se debe a que: cada vez que se crea una función, se creará automáticamente un objeto prototipo, y este objeto creará un constructor de forma predeterminada. Entonces, aquí nuestra esencia es reescribir el prototipo predeterminado, por lo que el nuevo constructor también se ha convertido en una señalización a la función del objeto, que ya no apunta a la función de la persona. Si el constructor es realmente importante, entonces debe escribir el constructor: persona.

Después de eso, necesitamos conocer la dinámica del prototipo. Cambiar las propiedades en el objeto prototipo se reflejará en la instancia, independientemente de si la instancia se crea antes o después de los cambios genéricos del objeto prototipo.

 function Person () {} Person.prototype = {First_Name: "Guo", Hair_Color: "Black", City: "Zhengzhou", Act: function () {Alert ("Eatation");}}; var boy = nueva persona (); Persona.prototype.hobby = "baloncesto"; var niña = nueva persona (); alerta (boy.hobby); //baloncesto

Como se muestra en el código anterior, incluso si la modificación de las propiedades prototipo del objeto ocurre después de la creación de la instancia, la instancia de niño todavía comparte persona.prototype.hobby.

Sin embargo, esta situación solo ocurre cuando se modifica el atributo de objeto prototipo. Cuando el atributo de objeto prototipo se reescribe por completo, la creación de la instancia debe colocarse después de que el atributo de objeto prototipo reescribe, de lo contrario se producirá un error.

 función persona () {} var niña = nueva persona (); Person.prototype = {First_Name: "Guo", Hair_Color: "Black", City: "Zhengzhou", Act: function () {Alert ("Eatation");}}; var boy = nueva persona (); Persona.prototype.hobby = "baloncesto"; alerta (boy.hobby); // alerta de baloncesto (girl.first_name); //indefinido

Volviendo al tema del "bloqueo", aprendimos anteriormente que crear el atributo de un objeto de instancia (el mismo nombre que un cierto atributo en el objeto prototipo) bloqueará el atributo del objeto prototipo, pero no afectará a otros objetos de instancia. Hay un error aquí. Esta situación solo se aplica a los tipos de datos básicos. Cuando el valor del atributo se refiere al tipo, se producirá un gran problema. Ver el siguiente código.

 function persona () {} persona.prototype = {first_name: "guo", peinado_color: "negro", amigos: ["nick", "John"], ciudad: "zhengzhou", act: function () {alert ("eatation");}}; var boy = nueva persona (); Boy.friends.push ("Mike"); var niña = nueva persona (); alerta (chico. Friends); // Nick, John, Mike Alert (Girl.Friends); // Nick, John, Mike

Se puede ver que la oración anterior no se aplica, porque los amigos existen en el objeto prototipo, no en el niño, por lo que su modificación afectará este entorno. (Podemos crear una propiedad de una instancia de niño a través de boy.frindes = []) Entonces, necesitamos introducir una combinación de patrones de constructor y patrones prototipos.

 Function Person (Hair_Color, City) {this.hair_color = way_color; this.city = City; this.friends = ["John", "Nick"]; } Persona.prototype = {constructor: persona, first_name: "guo", acto: function () {alert ("eatation"); }}; var boy = nueva persona ("negro", "zhengzhou"); var niña = nueva persona ("rojo", "shenyang"); Boy.friends.push ("Nick"); alerta (niña. Friends); alerta (chico. Friends);

Este modo es el método más utilizado y más reconocido para crear tipos personalizados en ECMAScript, e incluso puede usarse como modo predeterminado.

Pero para los programadores que trabajan en otros lenguajes orientados a objetos, este patrón parece extraño. Para encapsular toda la información en el constructor, aparece el patrón de prototipo dinámico. El modo dinámico utiliza principalmente una instrucción IF para determinar si el objeto prototipo debe inicializarse para lograr el propósito de guardar recursos.

Además, existe un modo de construcción seguro para adaptarse a la situación en la que no hay atributo compartido y no utilizar esto.

El análisis del prototipo anterior en JavaScript [recomendado] es todo el contenido que comparto con usted. Espero que pueda darle una referencia y espero que pueda apoyar más a Wulin.com.