JavaScript verwendet keine Prototypen und keine neuen Tipps zur Implementierung des Vererbungsmechanismus

Diese Methode ist nicht die ursprüngliche Kreation des Autors. Ich habe sie nur auf der Grundlage meiner Vorgänger zusammengefasst und eine einfache und praktische JavaScript-Vererbungsmethode entwickelt.

Die herkömmliche JavaScript-Vererbung basiert auf der Prototypenkette und erfordert die Verwendung einer großen Anzahl neuer Operationen. Der Code ist nicht präzise genug, die Lesbarkeit ist nicht sehr gut und er scheint anfällig für die Verschmutzung der Prototypenkette zu sein .

Die vom Autor zusammengefasste Vererbungsmethode ist prägnant und klar. Obwohl es nicht die beste Methode ist, hoffe ich, dass sie die Leser inspirieren kann.

Okay, kein Unsinn mehr, schauen Sie sich einfach den Code an, die Kommentare sind detailliert, Sie können es auf einen Blick verstehen~~~

Code kopieren Der Code lautet wie folgt:

 /**
* Créé par Yang Yuan le 14-11-11.
* Implémenter l'héritage sans utiliser de prototype
*
​*/
 /**
* Copie d'objet Javascript, un seul calque est copié, et seul l'attribut de fonction est copié, ce qui n'est pas universel !
* @param obj L'objet à copier
* @returns Objet
​*/
 Objet.prototype.clone = fonction(){
     var _s = ceci,
         nouvelObj = {};
     _s.each(fonction(clé, valeur){
         if(Object.prototype.toString.call(value) === "[object Function]"){
             newObj[key] = valeur;
         >
     });
     retourner newObj;
 };
 /**
* Parcourez tous ses propres attributs d'obj
*
* Fonction de rappel @param. Le rappel contiendra deux paramètres : le nom de l'attribut clé, la valeur de l'attribut valeur
​*/
 Object.prototype.each = function(callback){
     var clé = "",
         _this = ceci;
     pour (saisissez _this){
         if(Object.prototype.hasOwnProperty.call(_this, key)){
             rappel(clé, _this[clé]);
         >
     >
 };
 /**
* Créer une sous-classe
* @param ext obj, contient des méthodes qui doivent être réécrites ou étendues.
* @returns Objet
​*/
 Objet.prototype.extend = fonction (ext){
     var enfant = this.clone();
     ext.each(fonction(clé, valeur){
         enfant[clé] = valeur;
     });
     retour enfant ;
 };
 /**
* Créer un objet (instance)
* Les arguments @param acceptent n'importe quel nombre de paramètres comme liste de paramètres du constructeur
* @returns Objet
​*/
 Objet.prototype.create = fonction(){
     var obj = this.clone();
     si(obj.construct){
         obj.construct.apply(obj, arguments);
     >
     retourner obj ;
 };
 /**
* Exemple d'utilisation
* Utilisez cette méthode d'héritage pour éviter le prototype encombrant et nouveau.
* Mais l'exemple actuel écrit par l'auteur ne peut hériter que de la fonction de la classe parent (qui peut être comprise comme une méthode membre).
* Si vous souhaitez hériter d'un contenu plus riche, veuillez améliorer la méthode de clonage.
*
*
​*/
 /**
*Animal (classe parent)
* @type {{construct : construire, manger : manger}}
​*/
 varAnimal = {
     construction : fonction(nom){
         this.name = nom;
     },
     manger : fonction(){
         console.log("Je m'appelle " this.name ". Je peux manger !");
     >
 };
 /**
* Oiseau (sous-catégorie)
* Birds remplace la méthode eat de la classe parent et étend la méthode fly
* @type {sous-classe|void}
​*/
 var Oiseau = Animal.extend({
     manger : fonction(nourriture){
         console.log("Je m'appelle " this.name ". Je peux manger de la " nourriture "!");
     },
     voler : fonction(){
         console.log("Je peux voler !");
     >
 });
 /**
* Créer une instance d'oiseau
* @type {Jim}
​*/
 var oiseauJim = Oiseau.create("Jim"),
     birdTom = Bird.create("Tom");
 birdJim.eat("ver");  //Je m'appelle Jim. Je peux manger des vers !
 oiseauJim.fly();  //Je peux voler !
 birdTom.eat("riz");  //Je m'appelle Tom. Je peux manger du riz !
 oiseauTom.fly();  //Je peux voler !