JavaScript tidak menggunakan prototaip dan baharu untuk melaksanakan petua mechanism_javascript warisan

Kaedah ini tidak asli kepada saya, saya hanya merumuskannya berdasarkan kerja sebelumnya dan menghasilkan kaedah pewarisan JavaScript yang mudah dan praktikal.

Warisan JavaScript tradisional adalah berdasarkan rantaian prototaip prototaip, dan memerlukan penggunaan sejumlah besar operasi baharu. Kod ini tidak cukup ringkas, kebolehbacaan tidak begitu kuat, dan nampaknya terdedah kepada pencemaran rantaian prototaip. .

Kaedah pewarisan yang diringkaskan oleh penulis adalah padat dan jelas Walaupun ia bukanlah kaedah yang terbaik, saya harap ia dapat memberi inspirasi kepada pembaca.

Okey, bukan main-main lagi, tengok kod, komen detail, boleh faham sepintas lalu~~~

Salin kod Kod adalah seperti berikut:

 /**
* Erstellt von Yang Yuan am 14.11.11.
* Implementieren Sie die Vererbung ohne Verwendung eines Prototyps
*
​*/
 /**
* Javascript-Objektkopie, nur eine Ebene wird kopiert und nur das Funktionsattribut wird kopiert, was nicht universell ist!
* @param obj Das zu kopierende Objekt
* @returns Object
​*/
 Object.prototype.clone = function(){
     var _s = this,
         newObj = {};
     _s.each(function(key, value){
         if(Object.prototype.toString.call(value) === "[object Function]"){
             newObj[key] = value;
         }
     });
     return newObj;
 };
 /**
* Durchlaufen Sie alle eigenen Attribute von obj
*
* @param Rückruf-Rückruffunktion. Der Rückruf enthält zwei Parameter: Schlüsselattributname, Wertattributwert
​*/
 Object.prototype.each = function(callback){
     var key = "",
         _this = this;
     for (key in _this){
         if(Object.prototype.hasOwnProperty.call(_this, key)){
             callback(key, _this[key]);
         }
     }
 };
 /**
* Unterklasse erstellen
* @param ext obj, enthält Methoden, die überschrieben oder erweitert werden müssen.
* @returns Object
​*/
 Object.prototype.extend = function(ext){
     var child = this.clone();
     ext.each(function(key, value){
         child[key] = value;
     });
     Kind zurückbringen;
 };
 /**
* Objekt (Instanz) erstellen
* @param arguments akzeptiert eine beliebige Anzahl von Parametern als Konstruktorparameterliste
* @returns Object
​*/
 Object.prototype.create = function(){
     var obj = this.clone();
     if(obj.construct){
         obj.construct.apply(obj, arguments);
     }
     return obj;
 };
 /**
*Verwendungsbeispiel
* Verwenden Sie diese Vererbungsmethode, um umständliche Prototypen und neue zu vermeiden.
* Das aktuelle vom Autor geschriebene Beispiel kann jedoch nur die Funktion der übergeordneten Klasse erben (die als Mitgliedsmethode verstanden werden kann).
* Wenn Sie umfangreichere Inhalte erben möchten, verbessern Sie bitte die Klonmethode.
*
*
​*/
 /**
* Tier (Elternklasse)
* @type {{construct: construction, eat: eat}}
​*/
 var Tier = {
     Konstrukt: Funktion(Name){
         this.name = name;
     },
     eat: function(){
         console.log("Mein Name ist "this.name". Ich kann essen!");
     }
 };
 /**
* Vogel (Unterkategorie)
* Birds überschreibt die eat-Methode der übergeordneten Klasse und erweitert die fly-Methode
* @type {subclass|void}
​*/
 var Bird = Animal.extend({
     essen: Funktion(Nahrung){
         console.log("Mein Name ist " this.name ". Ich kann " food " essen!");
     },
     fliegen: function(){
         console.log("Ich kann fliegen!");
     }
 });
 /**
* Vogelinstanz erstellen
* @type {Jim}
​*/
 varbirdJim = Bird.create("Jim"),
     BirdTom = Bird.create("Tom");
 BirdJim.eat("Wurm");  //Mein Name ist Jim. Ich kann Würmer essen!
 BirdJim.fly();  //Ich kann fliegen!
 BirdTom.eat("Reis");  //Mein Name ist Tom. Ich kann Reis essen!
 BirdTom.fly();  //Ich kann fliegen!