Cette méthode n'est pas originale par l'auteur. Je viens de le résumer sur la base des prédécesseurs et j'ai trouvé une méthode d'hérédité JavaScript concise et pratique.
Le JavaScript traditionnel hérite des chaînes de prototypes basées sur des prototypes et nécessite de nombreuses nouvelles opérations. Le code n'est pas assez concis, la lisibilité n'est pas très forte et il semble être facilement contaminé par les chaînes prototypes.
La méthode d'héritage résumé par l'auteur est concise et claire. Bien que ce ne soit pas la meilleure façon, j'espère que cela pourra inspirer les lecteurs.
D'accord, ne dites pas beaucoup de non-sens, regardez le code, les commentaires sont détaillés, vous pouvez le comprendre à première vue ~~~
La copie de code est la suivante:
/ **
* Créé par Yang Yuanon 14-11-11.
* N'utilisez pas le prototype pour implémenter l'héritage
*
* /
/ **
* Copie d'objets JavaScript, ne copie qu'une seule couche et copier uniquement les attributs de fonction, pas universel!
* objet @param obj à copier
* objet @returns
* /
Object.prototype.clone = function () {
var _s = ceci,
newObj = {};
_s.each (fonction (clé, valeur) {
if (object.prototype.tostring.call (valeur) === "[Fonction objet]") {
newObj [key] = valeur;
}
});
retourner newoBJ;
};
/ **
* Itérer à travers toutes ses propres propriétés
*
* Fonction de rappel de rappel @param. Le rappel contiendra deux paramètres: le nom d'attribut clé et la valeur de l'attribut de valeur
* /
Object.prototype.each = fonction (rappel) {
var key = "",
_Cis = this;
pour (clé dans _This) {
if (object.prototype.hasownproperty.call (_This, key)) {
callback (key, _this [key]);
}
}
};
/ **
* Créer des sous-classes
* @param ext obj, contient des méthodes qui doivent être réécrites ou étendues.
* objet @returns
* /
Object.prototype.extend = fonction (ext) {
var child = this.clone ();
ext.each (fonction (clé, valeur) {
enfant [key] = valeur;
});
retour de l'enfant;
};
/ **
* Créer un objet (instance)
* Les arguments @param peuvent accepter n'importe quel nombre de paramètres comme une liste de paramètres du constructeur
* objet @returns
* /
Object.prototype.create = function () {
var obj = this.clone ();
if (obj.construct) {
obj.construct.apply (obj, arguments);
}
retour obj;
};
/ **
* Exemple d'utilisation
* Utilisez cette méthode pour hériter, en évitant le prototype fastidieux et nouveau.
* Cependant, l'exemple que j'ai écrit ne peut hériter que de la fonction de la classe parent (peut être compris comme une méthode membre).
* Si vous souhaitez hériter de contenu plus riche, veuillez améliorer la méthode du clone.
*
*
* /
/ **
* Animaux (parent)
* @Type {{construire: construire, manger: manger}}
* /
var animal = {
Construction: fonction (nom) {
this.name = name;
},
manger: function () {
console.log ("Mon nom est" + this.name + ". Je peux manger!");
}
};
/ **
* Oiseau (sous-classe)
* Oiseaux remplacés par la méthode de la classe des parents et étendez la méthode de la mouche
* @type {sous-classe | void}
* /
var oiseau = animal.extend ({
manger: fonction (nourriture) {
console.log ("Mon nom est" + this.name + ". Je peux manger" + aliments + "!");
},
fly: function () {
console.log ("Je peux voler!");
}
});
/ **
* Créer une instance d'oiseau
* @Type {Jim}
* /
var Birdjim = Bird.Create ("Jim"),
Birdtom = Bird.Create ("Tom");
Birdjim.eat ("ver"); // Je m'appelle Jim. Je peux manger du ver!
Birdjim.fly (); // Je peux voler!
Birdtom.eat ("riz"); // Je m'appelle Tom. Je peux manger du riz!
Birdtom.fly (); // Je peux voler!