2. Constructeur d'emprunt
Pour résoudre le problème causé par l'inclusion de valeurs de type de référence dans le prototype, nous utilisons une technique appelée vol de constructeur d'empruntes (également appelée objets forgés ou héritage classique).
L'idée de base de cette technique: appelez le constructeur de supertype à l'intérieur du constructeur de sous-classe.
Le constructeur peut être exécuté sur l'objet sous-classe nouvellement créé en utilisant les méthodes applicables () et call ().
fonction superType () {this.colors = ["red", "bleu", "vert"];} fonction de fonction de fonction () {// supertype hérité supertype.apply (this);} var instance1 = new sous-type (); instance1.colors.push ("noir"); alert (instance1.colors); // rouge, bleu, vert, instance BlackVar2 = nouveau sous-type (); alert (instance2.colors); // rouge, bleu, vertDans l'exemple ci-dessus, le constructeur SuperType est réellement appelé dans l'environnement de l'instance de sous-type nouvellement créée (instance1 instance2). De cette façon, tous les codes d'initialisation des objets définis dans la fonction SuperType () seront exécutés sur le nouvel objet sous-type. Ainsi, chaque instance de sous-type aura sa propre copie de l'attribut Couleurs.
Paramètres de passage
Pour les chaînes prototypes, les constructeurs d'emprunt ont un grand avantage, c'est-à-dire que vous pouvez transmettre des paramètres dans les constructeurs de supertype dans les constructeurs de sous-type.
fonction superType (name) {this.name = name;} function sub-type () {supertype.call (this, "bob"); this.age = 18;} var instance1 = nouveau sous-type (); alert (instance1.age); //18Alert(Instance1.name); //BobProblème d'emprunt des constructeurs:
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.
3. Hémit de combinaison
L'héritage combiné, parfois appelé héritage pseudo-classique, fait référence à la combinaison des prototypes de chaînes et des techniques de constructeur d'emprunt. Il s'agit d'un mode d'héritage qui joue les forces des deux.
Utilisez des chaînes prototypes pour implémenter l'héritage des propriétés et méthodes prototypes;
L'héritage des propriétés d'instance est réalisé en empruntant les constructeurs.
De cette façon, la réutilisation de la fonction est obtenue en définissant des méthodes sur le prototype, et il peut également garantir que chaque instance a ses propres attributs.
fonction supertype (name) {this.name = name; this.colors = ["red", "bleu", "vert"];} supertype.prototype.sayname = function () {alert (this.name);} fonction de fonction (nom, Âge) {// attribut héritage supertype.call (ce, nom); this.age = Âge;} // Méthode d'héritage sous-type.prototype = new SuperType (); Sous-type.prototype.sayage = function () {alert (this.age);} var instance1 = nouveau sous-type ("bob", 22); instance1.colors.push ("noir"); alert (instance1.colors); //red,Blue,Green,BlackEnstance1.SayName (); //Bobinstance1.sayage (); // 22var instance2 = nouveau sous-type ("Alice", 21); alert (instance2.colors); //red,Blue,GreenInstance2.SayName (); //Aliceinstance2.sayage (); // 21Dans cet exemple, le constructeur de supertype définit deux propriétés: le nom et les couleurs. Le prototype de SuperType définit une méthode sdetName ().
Le constructeur du sous-type passe dans le paramètre de nom lors de l'appel du constructeur SuperType et définit son propre âge d'attribut. Attribuez ensuite l'instance de SuperType au prototype du sous-type. La méthode Sayage () est définie sur ce prototype.
Cela permet à deux instances de sous-type différentes d'avoir leurs propres propriétés - y compris les attributs de couleurs, et la même méthode peut être utilisée.
L'article ci-dessus parle brièvement des constructeurs et de l'héritage des combinaisons JS Héritation_Borrow est tout le contenu que je partage avec vous. J'espère que vous pourrez vous faire référence et j'espère que vous pourrez soutenir Wulin.com plus.