L'héritage basé sur la chaîne du prototype de JavaScript

JavaScript n'est pas un langage orienté objet et ne fournit pas de méthodes d'héritage traditionnelles, mais il fournit un moyen d'hérédité prototype, en utilisant les propriétés prototypes qu'il fournit pour obtenir l'héritage.

La chaîne prototype est la principale méthode d'héritage en JavaScript.

L'idée de base de la chaîne prototype est: utiliser des prototypes pour permettre à un type de référence pour hériter des propriétés et des méthodes d'un autre type de référence.

Relation entre les constructeurs, les prototypes et les instances: chaque constructeur a un objet prototype, l'objet prototype contient un pointeur vers le constructeur et l'instance contient un pointeur interne vers l'objet prototype.

Si l'objet prototype est égal à une instance d'un autre objet, l'objet prototype contiendra un pointeur vers un autre prototype, et en conséquence, l'autre prototype contient également un pointeur vers un autre constructeur.

Mode de base de la mise en œuvre de la chaîne prototype:

 function SuperType() {this.property = true;}SuperType.prototype.getSuperValue = function () {return this.property;};function SubType() {this.subproperty = false;}// Inherit SuperTypeSubType.prototype = new SuperType();SubType.prototype.getSubValue = function () {return this.subproperty;}; var instance = new sous-type (); alert (instance.getsUpervalue ()); // vrai

Le sous-type hérite de SuperType, qui est réalisé en créant une instance de SuperType et en attribuant l'instance au sous-type.protype. L'essence de l'implémentation consiste à réécrire l'objet prototype et à le remplacer par une instance d'un nouveau type. De cette façon, les propriétés et les méthodes qui existent à l'origine dans l'instance de supertype existent également dans le sous-type.prototype. Ensuite, ajoutez une méthode à sous-type.prototype, qui ajoute une autre méthode basée sur l'héréditation des propriétés et des méthodes de supertype.

La relation d'instance dans l'exemple ci-dessus est exprimée comme suit:

Ce qui précède n'utilise pas le prototype fourni par le sous-type par défaut, mais le remplace plutôt par un nouveau prototype; Ce nouveau prototype est une instance de SuperType. Il existe également un pointeur vers le prototype qui exécute SuperType à l'intérieur du nouveau prototype. En conséquence, l'instance indique le prototype de sous-type, qui pointe le prototype de supertype. La méthode getValue () est toujours dans supertype.prototype, mais le prototype est dans le sous-type.protype. En effet, la propriété est une propriété d'instance et GetSupervalue () est une méthode prototype. Étant donné que le sous-type.prototype est désormais une instance de supertype, la propriété est naturellement située dans ce cas.

Remarque: instance.Constructor pointe désormais vers SuperType, car le prototype de sous-type pointe vers un autre objet - le prototype de SuperType et l'attribut constructeur de cet objet prototype pointe vers SuperType.

Lorsque vous accédez à un attribut en mode lecture, l'instance est d'abord recherchée cet attribut. Si la propriété n'est pas trouvée. Ensuite, la recherche du prototype de l'instance se poursuivra. Lorsque l'héritage est réalisé via la chaîne prototype, le processus de recherche peut continuer à se déplacer vers le haut le long de la chaîne prototype.

Prototype par défaut

Tous les types de référence héritent de l'objet par défaut, et cet héritage est également implémenté via la chaîne prototype. Le prototype par défaut de toutes les fonctions est une instance d'objet. Par conséquent, le prototype par défaut contiendra un pointeur interne vers Object.prototype. C'est pourquoi les types personnalisés hériteront de méthodes telles que toString (), valeurof (), etc.

Chaîne prototype complète:

Dans le système d'héritage ci-dessus, le sous-type hérite de supertype et SuperType hérite de l'objet. Lorsque instance.toString () est appelé, la méthode enregistrée dans object.prototype est réellement appelée.

Déterminer la relation entre l'instance et le prototype

Il existe deux façons de déterminer la relation entre un prototype et une instance:

Utiliser l'instance de l'opérateur

 alert (instance instanceOf objet); alert (instance instanceof supertype); alert (instance d'instance de sous-type);

En raison de la relation entre la chaîne prototype, tout ce qui précède revient vrai.

Utiliser la méthode isPrototypeOf ()

 alert (object.prototype.isprototypeof (instance)); alert (supertype.prototype.isprototypeof (instance)); alert (sous-type.prototype.isprototypeof (instance)); alert (sous-type.prototype.isprototypeof (instance));

Définissez soigneusement la méthode

Le code pour ajouter des méthodes au prototype doit être placé après l'instruction qui remplace le prototype.

 fonction superType () {this.property = true;} supertype.prototype.getsUpervalue = function () {return this.property;}; function sous-type () {this.subproperty = false;} supertype.prototype = new supertype (); // ajouter la méthode sous-type. this.subproperty;}; // écraser le sous-type de méthode.prototype.getsupervalue = function () {return this.subproperty;}; // écraser la méthode sous-type.prototype.getsupervalue = function () {return false;}; var instance = new SubType (); allert (instance.getSuperArd ()); // FAUX

Dans l'exemple ci-dessus, il faut noter qu'après avoir remplacé le prototype par l'instance de SuperType, définissez ces deux méthodes.

De plus, lors de l'héritage de la chaîne prototype, vous ne pouvez pas utiliser l'objet littéral pour créer une méthode prototype. Parce que cela réécrira la chaîne prototype:

 function SuperType() {this.property = true;}SuperType.prototype.getSuperValue = function () {return this.property;};function SubType() {this.subproperty = false;}// Inherit SuperTypeSubType.prototype = new SuperType();// Add a new method using literals, resulting in the previous line of code sous-type invalid.prototype = {getSubValue: function () {return this.subproperty;}, SomeotherMethod: function () {return false;}}; var instance = new SubType (); alert (instance.getsupervalue ()); // erreur

L'exemple ci-dessus attribue l'instance de SuperType au prototype, puis remplace le prototype par un littéral d'objet. Le prototype actuel contient une instance d'objet, pas une instance de supertype, et il n'y a pas de relation entre le sous-type et le supertype.

Problème de chaîne prototype

Comme mentionné précédemment, les attributs du prototype contenant des types de référence sont partagés par toutes les instances; C'est pourquoi les attributs doivent être définis dans le constructeur plutôt que dans l'objet prototype.

 fonction superType () {this.colors = ["red", "bleu", "vert"];} fonction de la fonction () {} sous-type.prototype = new SuperType (); var instance1 = nouveau sous-type (); instance1.colors.push ("noir"); alert (instance1.Colors); // "rouge", "bleu", "vert", "noir" var instance2 = nouveau sous-type (); alert (instance2.colors); // "rouge", "bleu", "vert", "noir"

Dans l'exemple ci-dessus, une propriété de couleurs est définie dans le constructeur SuperType, qui contient un tableau, et chaque instance de SuperType aura une propriété de couleurs qui contient son propre tableau. Après que le sous-type hérite de SuperType à travers la chaîne prototype, le sous-type.pototype devient une instance de supertype, il a donc également son propre attribut de couleurs. Cependant, toutes les instances de sous-type partagent cette propriété One Colors.

Un autre problème est qu'il n'y a aucun moyen de transmettre des paramètres au constructeur Superclass sans affecter toutes les instances d'objet.

Ce qui précède est la connaissance pertinente de JavaScript basée sur l'héritage de la chaîne prototype que l'éditeur vous a présenté. J'espère que cela vous sera utile. Si vous avez des questions, veuillez me laisser un message et l'éditeur vous répondra à temps. Merci beaucoup pour votre soutien au site Web Wulin.com!