Résumé des exemples d'héritage en Javascript programmation_javascript skills

Les exemples de cet article décrivent l'héritage de la programmation Javascript. Partagez-le avec tout le monde pour votre référence, les détails sont les suivants :

Ce texte est un résumé après lecture de "Le retour du roi Javascript". Les chapitres détaillés de l'article se trouvent au chapitre 21 P537

L'héritage met généralement en œuvre les trois niveaux de sens suivants :

1) Les instances de sous-classe peuvent partager les méthodes de la classe parent
2) Les sous-classes peuvent remplacer les méthodes de la classe parent ou étendre de nouvelles méthodes
 ; 3) La sous-classe et la classe parent sont des types d’instances de sous-classe.

1. Méthode d'héritage structurel

La sous-classe appelle le constructeur de la classe parent pour la maintenir.Cette méthode d'héritage peut réaliser un héritage multiple, mais elle ne peut hériter que des méthodes communes de la classe parent, ne peut pas hériter des méthodes statiques et instanceof ne peut pas être utilisée pour vérifier le exemple.

function a(){
  this.say=function(){
  alert("happy new year！");
  }
}
function b(){
  a.apply(this,arguments);
}
a.prototype.fuck=function(){
  alert("%^&%^&%&^%&");
}
var oB=new b();
alert(oB instanceof a);// false
oB.say();       // happy new year
oB.fuck();       // 读不到

2. Héritage prototypique/héritage classique

Cette méthode d'héritage permet de réutiliser le comportement en copiant un objet prototype existant, permettant aux instances d'objet de partager les propriétés de l'objet prototype. Prend en charge l'héritage multiple, hérite des méthodes statiques des prototypes et peut utiliser instanceof pour vérifier les instances.

function a(){
 this.say=function(){
 alert("happy new year！");
 }
}
function b(){}
a.prototype.fuck=function(){
  alert("%^&%^&%&^%&");
}
a.prototype.z=123;
b.prototype=new a();
var oB=new b();
alert(oB instanceof a); // true
alert(oB.z);      // 123
oB.say();        // happy new year
oB.fuck();       // %^&%^&%&^%&

3. Héritage d'instance/modèle de constructeur parasite

La méthode de construction ne peut pas hériter des méthodes statiques du type, et l'héritage du prototype est incomplet (les méthodes non énumérables de certains objets principaux ne peuvent pas être héritées), tandis que la méthode d'héritage d'instance peut hériter des objets principaux natifs ou des objets DOM . Il utilise le type L'héritage est implémenté en construisant un objet et en le renvoyant, donc l'instance de vérification sera fausse et l'héritage multiple n'est pas pris en charge.

function a(){
 var oA=new Array();
 oA.say=function(){
   alert("hello A!");
 }
 return oA;
}
var obj=new a();
alert(obj instanceof a); // false
obj.say();

4. Méthode d'héritage de copie

Cette méthode simule l'héritage en copiant toutes les propriétés et méthodes énumérables de l'objet de classe de base, elle peut donc simuler un héritage multiple, mais celles qui ne peuvent pas être énumérées ne peuvent pas être héritées, elle peut hériter des méthodes statiques de la classe parent ; >

function a(){
  this.num=123;
  this.say=function(){
  alert("happy new year！");
  }
}
function b(){
  this.extends=function(obj){
    for(each in obj){
      this[each]=obj[each];
    }
  }
}
var oB=new b();
oB.extends(new a());
alert(oB instanceof a); // false
alert(oB.num);     // 123
oB.say();        // happy new year

5. Méthode d'héritage mixte

function a(){
  this.num=123;
  this.say=function(){
  alert("happy new year！");
  }
}
function b(){
  a.apply(this);
}
b.prototype=new a();
b.prototype.z=123;
var oB=new b();
alert(oB instanceof a); // true
alert(oB.num);     // 123
oB.say();        // happy new year

6. Avantages et inconvénients des diverses lois sur les successions