L'héritage est un moyen très important lorsque nous implémentons la programmation orientée objet. Bien que nous disions que nous ne pouvons pas hériter et utiliser plus de combinaisons au lieu de l'héritage, l'héritage est toujours inévitable. Ce que nous voulons discuter ici, c'est du mécanisme d'héritage en JavaScript.
Il n'y a en fait aucun concept d'hérédité en JavaScript, mais nous pouvons l'imiter par certains moyens. Cet héritage copie en fait un objet dans un autre. Vous devez noter que toutes les classes locales et hôtes ne peuvent pas être héritées en tant que classes de base, principalement pour les considérations de sécurité.
Il y a environ trois catégories d'héritage en JavaScript: 1. Impersonation des objets; 2. Héritage du prototype; 3. Mélange des deux.
1. Imitation de l'objet
En fait, l'identification des objets est étroitement liée à ce mot-clé (il est donc important de comprendre pleinement ce mot-clé en javascript: p). Le constructeur l'utilise pour attribuer des valeurs aux attributs et aux méthodes, et le constructeur peut également être considéré comme une fonction ordinaire, afin que nous puissions faire du constructeur de notre classe de base un constructeur de la sous-classe, puis appeler cette fonction à l'intérieur de la sous-classe, et la sous-classe obtiendra les propriétés et méthodes de la classe parent.
Le principe est très simple, alors comment l'implémenter? Prenons une opération pratique en utilisant l'exemple de code.
Méthode de mise en œuvre 1 de l'identité des objets , notre méthode la plus couramment utilisée pour créer de nouveaux objets:
La copie de code est la suivante:
var classa = fonction (name) {
this.name = name;
this.AlertName = function () {
alert (this.name);
}
}
var classb = fonction (nom, âge) {
this.myconstructor = classa;
this.myconstructor (nom);
Supprimer ce.myconstructor;
this.age = âge;
this.Alertage = function () {
alerte (this.age);
}
}
Afin de vérifier si la méthode ci-dessus est correcte, vous pouvez la tester vous-même. J'écrirai le code utilisé pour le test ci-dessous:
La copie de code est la suivante:
var obja = new classa ('dk');
obja.AlertName (); // dk
var objb = new classb ('ds', 20);
objb.AlertName (); // ds
objb.lerage (); // 20
C'est ce qu'on appelle l'identité des objets. De plus, il existe deux autres façons de mettre en œuvre l'identité des objets. Bien que leurs méthodes de mise en œuvre soient différentes, leurs principes sont les mêmes.
Méthode d'implémentation d'identification des objets 2 , utilisez la méthode d'appel:
La copie de code est la suivante:
var classa = fonction (name) {
this.name = name;
this.AlertName = function () {
alert (this.name);
}
}
var classb = fonction (nom, âge) {
classa.call (ce, nom);
this.age = âge;
this.Alertage = function () {
alerte (this.age);
}
}
Il peut également être vu à travers le code qui, dans la première méthode, nous avons créé un nouveau pointeur de fonction pour pointer vers la classe parent, appelé la fonction, puis supprimé le pointeur. Ici, nous utilisons la méthode d'appel pour exécuter le constructeur de la classe parent sous cet objet, atteignant le même objectif. De plus, la méthode d'appel est la méthode d'application.
Méthode d'implémentation d'identification des objets Trois , utilisez la méthode d'application:
La copie de code est la suivante:
var classa = fonction (name) {
this.name = name;
this.AlertName = function () {
alert (this.name);
}
}
var classb = fonction (nom, âge) {
classa.apply (this, nouveau array (nom));
this.age = âge;
this.Alertage = function () {
alerte (this.age);
}
}
En fait, vous pouvez voir que la méthode d'application est très similaire à la méthode d'appel, sauf que les paramètres sont légèrement différents.
2. Héritage prototype
Tout le monde devrait comprendre l'objet prototype. Toutes les propriétés et méthodes de l'objet Prototype seront transmises à toutes les instances de la classe. Toutes les propriétés et méthodes de la classe parent sont versées à l'objet prototype de la classe enfant, ce qui équivaut à réaliser notre héritage.
Si une sous-classe souhaite obtenir toutes les propriétés et méthodes de la classe parent, nous paierons directement une instance de la classe parent à l'objet prototype de la sous-classe. Alors notre sous-classe n'est-elle pas équivalente à l'obtention de tous les objets et méthodes de la classe parent?
Exemple de service de code:
La copie de code est la suivante:
var classa = function () {
this.name = 'dk';
this.AlertName = function () {
alert (this.name);
}
}
var classb = fonction (nom, âge) {
this.name = name;
this.age = âge;
}
classb.prototype = new classa ();
classb.prototype.lertage = function () {
alerte (this.age);
}
Notez que le constructeur de la classe parent ici doit s'assurer qu'il n'y a pas de paramètres. Parce que même s'il y a des paramètres de constructeur, vous ne pouvez pas passer =. = Lors de la mise en œuvre de l'héritage du prototype!
3. Héritage mixte
Comme son nom l'indique, l'héritage hybride est l'utilisation mixte des deux premières méthodes.
La copie de code est la suivante:
var classa = fonction (name) {
this.name = name;
}
Classa.prototype.AlertName = function () {
alert (this.name);
}
var classb = fonction (nom, âge) {
classa.call (ce, nom);
this.age = âge;
}
classb.prototype = new classa ();
classb.prototype.lertage = function () {
alerte (this.age);
}
L'utilisation de l'identité d'objet implémente les paramètres de passage à la classe parent, et l'utilisation de l'héritage du prototype met en œuvre l'héritage des méthodes publiques.
Après avoir parlé des méthodes d'héritage dans ces trois domaines, il est temps de parler du problème ci-dessous.
Vous pouvez être perplexe, pourquoi avez-vous besoin de créer un héritage mixte avec l'identité d'objet et l'héritage prototype? Oui, la chose la plus importante est cette question.
1. Si vous le testez réellement, vous constaterez que l'héritage implémenté par l'identité d'objet et que la sous-classe ne peut pas accéder aux méthodes de la chaîne prototype de la classe parent.
2. L'héritage avec les prototypes transformera tous les attributs en attributs partagés. Si vous implémentez deux instances dans la même sous-classe, vous constaterez que toutes vos instances partagent tous les attributs.
3. Mais c'est définitivement inapproprié. Il existe donc une méthode d'héritage hybride, qui permet aux attributs de rester privés et permet aux sous-classes d'accéder à la chaîne prototype de la classe parent.
Vous pouvez l'essayer vous-même. Lorsque l'objet imite l'héritage, la sous-classe ne peut pas accéder à la méthode de la chaîne prototype de la classe parent. Toutes les instances de la sous-classe de l'héritage de la chaîne prototype partagent tous les attributs de classe parent. Je n'écrirai pas d'exemples ici.