Héritage JS: Emprunter le constructeur Héritage et combinaison héritage

Emprunter l'héritage du constructeur

Pour résoudre le problème de l'inclusion de valeurs de type de référence dans un prototype, les développeurs ont commencé à utiliser une technique appelée vol de constructeur d'empruntes (parfois appelé objets forgés ou héritage classique). L'idée de base de cette technique est assez simple, à savoir appeler le constructeur de supertype à l'intérieur du constructeur du sous-type.

Mode de base

 fonction supertype () {this.colors = ["red", "bleu", "vert"];} fonction de fonction de fonction () {// supertype hérité supertype.call (this);} var instance1 = new sous-type (); instance1.colors.push ("noir"); alert (instance1.colors); // "rouge, bleu, vert, noir" var instance2 = nouveau sous-type (); alert (instance2.colors); // "rouge, bleu, vert"

Idées de base

L'idée de base d'emprunter des constructeurs est d'utiliser l'appel ou de s'appliquer pour copier (emprunter) les propriétés et méthodes spécifiées dans la classe parent dans l'instance créée par la sous-classe. Parce que cet objet est lié à l'exécution en fonction de l'environnement d'exécution de la fonction. C'est-à-dire, à l'échelle mondiale, cela est égal à la fenêtre, et lorsqu'une fonction est appelée méthode d'un objet, cela est égal à cet objet. Les méthodes d'appel et d'application peuvent être utilisées pour appeler une méthode au lieu d'un autre objet. Les méthodes d'appel et d'application peuvent modifier le contexte de l'objet d'une fonction du contexte initial à un nouvel objet spécifié par ThisOBJ.

Par conséquent, ce constructeur d'emprunt est, lorsque le nouvel objet est appelé (notez que le nouvel opérateur est différent de l'appel direct. Lorsque la fonction est appelée, cela pointe vers la fenêtre. Lorsque le nouveau est créé, cela pointe vers l'instance créée), un nouvel objet d'instance est créé et le code du sous-type est exécuté. L'appel des appels de sous-type SupertyEp, ce qui signifie que ce pointage est modifié en pointant vers une nouvelle instance, de sorte que ces attributs et méthodes connexes dans SuperType seront attribués à la nouvelle instance, plutôt que d'attribuer à Suptype. Toutes les instances ont ces propriétés et méthodes définies par la classe parent.

Avantages

Par rapport aux chaînes prototypes, les constructeurs d'emprunt ont un grand avantage, c'est-à-dire qu'ils peuvent transmettre des paramètres aux constructeurs de supertype dans les constructeurs de sous-type. Parce que l'attribut est lié à cela, il est attribué à l'instance correspondante lorsqu'elle est appelée, et les valeurs de chaque instance ne se affecteront pas mutuellement.

Par exemple:

 fonction superType (name) {this.name = name;} fonction sub-type () {// hérite de supertype, et transmet également le paramètre supertype.call (this, "Nicholas"); // instruts attribut this.age = 29;} var instance = new SubType (); alert (instruts.Name); //"Nicholas"; allert(Instance.age); // 29

Désavantage

Si vous empruntez simplement un constructeur, les problèmes avec le modèle de constructeur ne seront pas évités - les méthodes sont toutes définies dans le constructeur, il n'y a donc aucun moyen de parler de la réutilisation de la fonction. De plus, les méthodes définies dans les prototypes de supertype sont également invisibles pour les sous-types, et par conséquent, tous les types ne peuvent utiliser que des modèles de constructeur. Compte tenu de ces problèmes, la technique d'emprunt des constructeurs est également rarement utilisée seule.

Héritage combiné

L'héritage combiné, parfois appelé héritage pseudo-classique. Il s'agit d'un modèle d'héritage qui combine la chaîne prototype et la technologie du constructeur emprunté en une seule pièce, afin de jouer les forces des deux.

Idées de base

L'idée est d'utiliser la chaîne prototype pour implémenter l'héritage des propriétés et méthodes prototypes, et de mettre en œuvre l'héritage des propriétés d'instance en empruntant les constructeurs. De cette façon, le multiplexage des fonctions est réalisé en définissant des méthodes sur le prototype, et il peut également garantir que chaque instance a ses propres attributs.

Modèle de base

 fonction supertype (name) {this.name = name; this.colors = ["red", "bleu", "vert"];} supertype.prototype.sayName = function () {alert (this.name);}; fonction sous-type (nom, âge) {// attribut héritage supertype.call (this, nom); this.age = Âge;} // Méthode d'hérédité sous-type.prototype = new SuperType (); sous-type.prototype.constructor = sous-type; sous-type.prototype.sayage = fonction () {alert (this.age);}; var instance1 = new sous-type ("Nicholas",,,, 29); instance1.colors.push ("noir"); alert (instance1.colors); // "Instance" rouge, bleu, vert, noir "1.sayName (); // "Nicholas"; instance1.sayage (); // 29var instance2 = nouveau sous-type ("greg", 27); alert (instance2.colors); // instance "rouge, bleu, vert ".sayName (); // "greg"; instance2.sayage (); // 27

Avantages

L'héritage combiné évite les défauts des chaînes prototypes et des constructeurs empruntés, combine leurs avantages et devient le modèle d'héritage le plus couramment utilisé en JavaScript.

Désavantage

Le plus gros problème avec l'héritage combiné est que dans tous les cas, le constructeur de supertype sera appelé deux fois: une fois lors de la création d'un prototype de sous-type, et de l'autre fois à l'intérieur du constructeur de sous-types. Alors que les sous-types contiendront éventuellement toutes les propriétés d'instance de l'objet SuperType, nous devons remplacer ces propriétés lors de l'appel du constructeur de sous-type.

Ce qui précède est tout le contenu de cet article. J'espère que cela sera utile à l'apprentissage de tous et j'espère que tout le monde soutiendra davantage Wulin.com.