Héritage axé sur les objets JS --- Explication détaillée de l'héritage de combinaison multiple

Cette fois, nous parlerons de combinaison, prototype, parasite et méthodes d'héritage de combinaison parasitaire.

1. Héritage combiné : également connu sous le nom de pseudo-classique, il se réfère à une méthode d'héritage qui combine des chaînes prototypes et des technologies de constructeur empruntées en une seule pièce.

Jetons un coup d'œil à un exemple:

 fonction supertype (name) {this.name = name; this.colors = ["rouge", "bleu", "vert"]; } Supertype.prototype.sayName = function () {alert (this.name); } Sous-type de fonction (nom, âge) {superType.Call (this, name); 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 ("Nicholas", 29); instance1.colors.push ("noir"); alert (instance1.colors); // rouge, bleu, vert, noire 1.sayName (); // nicholas instance1.sayage (); // 29 var instance2 = nouveau sous-type ("Greg", 27); alert (instance2.colors); // instance rouge, bleu, vert2.sayName (); // greg instance2.sayage (); // 27

L'héritage combiné évite les lacunes des chaînes prototypes et des constructeurs d'emprunteurs, et intègre leurs avantages.

2. Héritage prototype

L'héritage peut être mis en œuvre sans constructeurs prédéfinis, effectuant essentiellement une copie superficielle d'un objet donné. La copie copiée peut être encore modifiée.

 Fonction Object (o) {fonction f () {}; F.prototype = o; retourner le nouveau F; } var personne = {nom: "Nicholas", amis: ["shelby", "cour", "van"]}; var an autre personne = objet (personne); autre personne.name = "Greg"; AnotherSerson.friends.push ("Rob"); var an autre personne = objet (personne); autre personne.name = "Linda"; autre personne.friends.push ("Barbie"); alerte (Person.friends); // Shelby, Court, Van, Rob, Barbie

3. Héritage parasite

Très similaire à l'héritage du prototype, il s'agit également de créer un objet basé sur un objet ou des informations, puis d'améliorer l'objet et enfin de renvoyer l'objet. Pour résoudre le problème d'inefficacité causé par le modèle d'héritage combiné en raison de plusieurs appels vers le constructeur de supertype, ce modèle peut être utilisé avec l'héritage combiné.

 Fonction Object (o) {fonction f () {}; F.prototype = o; retourner le nouveau F; } fonction createArother (original) {var clone = objet (original); clone.sayhi = function () {alert ("hi"); }; Clone de retour; } var personne = {nom: "Nicholas", amis: ["shelby", "cour", "van"]}; var un autre personne = Createanother (personne); autre personne.sayhi ();

4. Héritage de combinaison parasite

La combinaison des avantages de l'héritage parasitaire et de l'héritage combiné est le moyen le plus efficace de réaliser l'héritage de base.

 // Héritage de la fonction prototype Extend (sous-type, supertype) {fonction f () {}; F.prototype = supertype.prototype; var prototype = new f; prototype.constructor = sous-type; sous-type.prototype = prototype; } // Fonction de méthode Superclass SuperType (name) {this.name = name; this.colors = ["rouge", "bleu", "vert"]; } Supertype.prototype.sayName = function () {return this.name; } // Fonction de méthode de sous-classe SuperType (name) {this.name = name; this.colors = ["rouge", "bleu", "vert"]; } Supertype.prototype.sayName = function () {return this.name; } // Sous-type de fonction de méthode de sous-classe (nom, âge) {supertype.call (this, name); this.age = âge; } // prototype extend (sous-type, supertype); // Méthode de sous-classe sous-type.prototype.sayage = function () {return this.age; } var instance1 = nouveau sous-type ("shelby"); var instance2 = nouveau sous-type ("Court", 28); instance1.colors.push ('noir'); alert (instance1.colors); // Alerte rouge, bleu, vert, noir (instance2.colors); // Alerte rouge, bleu et vert (instance 1 sous-type de sous-type); // true alert (instance1 instanceof supertype); //vrai

L'efficacité de cet exemple se reflète en ce qu'il n'appelle le constructeur de supertype qu'une seule fois, et évite ainsi la création de propriétés inutiles inutiles sur le sous-type.prototype. Dans le même temps, la chaîne prototype peut rester inchangée. Par conséquent, l'instance OFF et ISPrototypeOf () peuvent également être utilisées normalement. Les développeurs croient généralement que l'héritage combinatoire parasite est le paradigme d'héritage le plus idéal pour les types de référence.

L'héritage axé sur l'objet JS ci-dessus - une explication détaillée de l'héritage de combinaison multiple 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.