Cet article résume l'utilisation de JavaScript sur l'héritage. Partagez-le pour votre référence. Les détails sont les suivants:
exemple:
Copiez le code comme suit: / **
* Les sous-classes d'implémentation héritent de la classe parent, mais ne génèrent pas de propriétés et de méthodes inutiles
* @returns {fonction}
* /
définir (function () {
Fonction de retour (sous-type, supertype) {
var proto = nouvel objet (supertype.prototype);
proto.constructor = sous-type;
sous-type.prototype = proto;
};
});
// - `` `` `` `` `` `` `` `` `` `` `` `` `` -
définir (function () {
fonction (s) de fonction (s)
{
this.str = s;
this.length = this.str.length;
}
ostring.prototype.show = function () {
alerte (this.str);
};
retournerstring;
});
// - `` `` `` `` `` `` `` `` `` `` `` `` `` -
définir (['hériter', 'ostring'], fonction (hériter, ostring) {
fonction wstring (s) {
// Utilisez l'appel au constructeur de la classe parent
Ostring.Call (ceci, s);
this.chlength = 2 * s.length;
}
// hériter d'autres attributs
héritage (wstring, ostring);
wstring.prototype.add = fonction (w)
{
alerte (this.str + w);
};
retour wstring;
});
Regardez à nouveau l'exemple
1. Utilisez la fonction pour implémenter:
Copiez le code comme suit: Personne de fonction (nom) {
this.name = name;
}
Personne.prototype.getName = function () {
Renvoie ce.name;
}
Auteur de fonction (nom, livres) {
this.inherit = personne;
this.inherit (nom);
this.books = livres;
}
var aU = nouvel auteur ("Dororo", "Apprenez beaucoup");
au nom
Ou équivalent:
Copiez le code comme suit: Personne de fonction (nom) {
this.name = name;
}
Personne.prototype.getName = function () {
Renvoie ce.name;
}
Auteur de fonction (nom, livres) {
Personne.Call (ceci, nom);
this.books = livres;
}
var aU = nouvel auteur ("Dororo", "Apprenez beaucoup");
Au.GetName
Étant donné que cela ne fait que prendre cela en tant que paramètre, appelant le constructeur de la personne de la classe parent et attribuant tous les domaines attribués à la classe parent à la sous-classe de l'auteur, tous les domaines définis en dehors du constructeur de la personne de classe parent ne seront pas hérités. Ainsi, dans l'exemple ci-dessus, AU.getName ne sera pas défini (non défini) car GetName est défini dans l'objet prototype de la personne.
De plus, le constructeur d'une sous-classe doit appeler le constructeur de la classe parent avant de définir son propre domaine, afin de ne pas écraser la définition de la sous-classe par la classe parent. En d'autres termes, l'auteur définit le livre de propriétés après personne.Call, sinon il sera écrasé par la propriété en personne. En même temps, il est préférable de ne pas utiliser le prototype pour définir le domaine de fonction de la sous-classe dans les sous-classes, car une fois une sous-classe nouvelle et instanciée, le prototype doit être exécuté, puis le constructeur de la classe parent est appelé, ce qui est également facile à être écrasé par les attributs de la classe parent.
2. Utilisez le prototype pour implémenter:
Copiez le code comme suit: Personne de fonction (nom) {
this.name = name;
}
Personne.prototype.getName = function () {
Renvoie ce.name;
}
Auteur de fonction (nom, livres) {
this.books = livres;
}
Auteur.prototype = new personne (nom);
Auteur.prototype.constructor = auteur;
Auteur.prototype.getBooks = function () {
Renvoie ce.books;
}
var au1 = nouvel auteur ("Dororo1", "Apprenez beaucoup");
var au2 = nouvel auteur ("dororo2", "apprendre moins");
alert (aU1.getName ());
alert (Au2.GetName ());
Cette méthode évite le problème que le prototype ne peut pas être hérité dans la mise en œuvre de la fonction. Parce que l'auteur.prototype = new personne (nom); l'instance new () appellera toutes les propriétés de la construction et du prototype de personne. Mais l'inconvénient est que l'auteur. Le prototype a été instancié. Ainsi, lorsque les sous-classes sont instanciées, tous les types de données non-base sont des copies de référence. Ainsi, dans l'exemple ci-dessus, la valeur renvoyée par l'exemple AU1 ou AU2 est Dororo1.
3. Utilisez "hybride" pour réaliser
Copiez le code comme suit: Personne de fonction (nom) {
this.name = name;
}
Personne.prototype.getName = function () {
Renvoie ce.name;
}
Auteur de fonction (nom, livres) {
this.base = new personne (nom);
pour (clé var dans ce.base) {
if (! cette [clé]) {
this [key] = this.base [key];
}
}
this.book = livres;
}
var au1 = nouvel auteur ("Dororo1", "travail");
var au2 = nouvel auteur ("dororo2", "play");
alert (aU1.getName ());
alert (Au2.GetName ());
AU1.Book;
AU2.Book;
Il appartient à une extension, copie tous les domaines de la classe parent à une sous-classe. Il n'y a aucun problème dans les deux aspects ci-dessus.
Mode combinaison parasite)
L'héritage de JS comprend l'hérédité des attributs et l'héritage des méthodes, qui sont implémentées par différentes méthodes.
1. Héritage des attributs
L'héritage des attributs est réalisé en modifiant l'environnement d'exécution de la fonction. L'environnement d'exécution de la modification de la fonction peut être implémenté à l'aide de deux méthodes: call () et appliquer ().
Nous créons d'abord une "classe" animale (car il n'y a pas de concept de classe dans JS, voici juste une simulation, c'est en fait juste un objet de fonction de fonction).
Copiez le code comme suit: fonction animal (typename) {
// Ajouter une propriété typename pour l'environnement d'exécution de la méthode actuelle (ceci)
// mais l'environnement d'exécution (ceci) doit être exécuté avant de pouvoir être déterminé
this.Typename = typename;
this.colors = ["rouge", "while"];
}
// Je veux ajouter deux méthodes (partagées d'objet) au prototype de la fonction
Animal.prototype.shout = function () {alert ("je suis: -" + this.typename);};
Animal.prototype.eat = function () {alert ("je suis: -" + this.typeName)};
// - Définir un lion - "classe" (en fait une fonction)
fonction lion (tn) {
// - Exécutez la méthode animale et modifiez l'environnement d'exécution animale à ce lion via le premier paramètre d'appliquer
// De même, les lions doivent être exécutés pour déterminer qui c'est
Animal.Apply (ceci, ["lion"]); // - hérite des attributs variables de la classe parent, c'est parce que c'est un nouveau lion, c'est du lion
}
Lion.prototype = animal.prototype; // Hérite de la méthode de la classe parent et faites-le mais ce n'est pas bien écrit. Lorsque la classe enfant ajoute une méthode, la classe parent a également cette méthode. Ceci est une référence de pointeur
Lion.prototype.hunt = function () {
alerte ("Je suis: Lion, je veux chasser ~~ ・ ~");
}
var aminm = nouvel animal ();
Aminm.Hunt (); // --- Vous pouvez accéder à la méthode de sous-classe, ce qui n'est pas bon
// ---- alors comment résoudre ce problème? ? ? ? ? ?
// --- Solution: vous pouvez écrire ceci lorsque vous héritez de la méthode:
Lion.prototype = new animal (); // hériter de la méthode de la classe parent et attribuer l'objet animal au prototype prototype. En fait, il y a également des attributs.
var lion = new lion (); // En plus de créer le nouveau mot clé, il modifiera également l'environnement d'exécution de l'objet Lion à l'objet Lion lui-même
// --- En d'autres termes, une fois le nouveau terminé, cela dans la fonction Lion est la fonction lion elle-même, puis la fonction de lion est appelée
Analyser les nouveaux mots clés:
Le nouveau mot-clé est très génial. Dans le code précédent, le nouveau mot-clé complète les tâches suivantes:
1) Ouvrez un espace de tas pour se préparer à stocker des objets lion
2) Modifiez l'environnement d'exécution de l'objet lion lui-même afin que celui-ci de la fonction lion pointe vers l'objet de fonction Lion lui-même.
3) Appelez le "constructeur" de la classe de lion "et créez un objet lion
4) Attribuez l'adresse de tas de l'objet de fonction Lion à la variable L, et à l'heure
lion.shout ();
lion.eat ();
Cependant, cet héritage a un désavantage: le constructeur de la classe parent est appelé deux fois, appelez une fois, puis nouveau à nouveau.
J'espère que cet article sera utile à la programmation JavaScript de tous.