Ein kurzer Vortrag über die parasitäre Kompositionsvererbung in JavaScript

Vererbung von Kompositionen

Kombinationsvererbung wird auch als pseudoklassische Vererbung bezeichnet. Sie kombiniert die Prototypenkette und den Konstruktordiebstahl, über die wir gestern gesprochen haben, und vereint die Vorteile beider. Die Grundidee besteht darin, die Eigenschaften und Methoden des Prototyps über die Prototypkette zu erben und die Instanzeigenschaften durch Stehlen des Konstruktors zu erben. Dies hat den Vorteil, dass die im Prototyp definierten Methoden wiederverwendet werden können und jede Instanz über eigene Eigenschaften verfügt.

    Funktion SuperType (Name) {
        dieser.name = Name;
        this.colors = ["rot","gelb","blau"];
    }
    SuperType.prototype.sayName = Funktion(){
        console.log(dieser.Name)
    }
    Funktion SubType(Name,Alter){
        SuperType.call(diesen,Name);
        dieses.Alter = Alter;
    }
    SubType.prototype = neuer SuperType();
    SubTyp.prototyp.sayAge = Funktion(){
        Konsole.log(dieses.Alter);
    }
    let instancel = neuer Subtyp("jackson",22);
    Instanzl.colors.push("pink");
    Instanzl.sayName(); // "Jackson"
    Instanzl.sayAge(); //22
    console.log(Instanz.Farben); // ["rot", "gelb", "blau", "pink"]
    
    let instance2 = neuer Subtyp("Bär", 20);
    console.log(instance2.colors); // ["rot", "gelb", "blau"]
    instance2.sayName(); // "Bär";
    Instanz2.sayAge(); // 20

Fühlen Sie sich durch den obigen Code plötzlich erleuchtet? SubType ruft SuperType auf, übergibt name und definiert dann seine eigene Eigenschaft age. Darüber hinaus wird SubType.prototype auch der SuperType-Instanz zugewiesen. Nachdem der Prototyp zugewiesen wurde, wird diesem Prototyp die Sayage-Methode hinzugefügt, wodurch zwei SubType-Instanzen erstellt werden. Diese beiden Instanzen haben ihre eigenen Eigenschaften und können dieselben Methoden gemeinsam nutzen.

Die kombinierte Vererbung gleicht die Mängel der Prototypenkette und des gestohlenen Konstruktors aus und ist der am häufigsten verwendete Vererbungsmodus in js.

Parasitäre Vererbung

Parasitäre Vererbung besteht darin, ein Objekt mit einer Funktion zu umhüllen und dann den Aufruf dieser Funktion zurückzugeben. Diese Funktion wird zu einer Instanz oder einem Objekt, dem nach Belieben Eigenschaften hinzugefügt werden können. Dies ist das Prinzip von object.create().

  // Parasitäre Vererbungsfunktion subobject(obj) {
        lass Klon = Objekt(obj);
        Klon.sayName = Funktion(){
            konsole.log("jackson")
        };
        Klon zurückgeben;
    }
    lass sub = {
        Name: „Bär“
    }
    lass sup = Unterobjekt(sub);
    sup.sayName();//jackson

Dieses Beispiel gibt ein neues Objekt basierend auf dem Subobjekt zurück. Das zurückgegebene Sup-Objekt hat die Eigenschaften und Methoden von Sub und eine neue Methode sayName().

Parasitäre Vererbung eignet sich auch für Szenarien, in denen Sie sich hauptsächlich mit Objekten befassen und sich nicht um Typen und Konstruktoren kümmern. Für die parasitäre Vererbung ist die Funktion object() nicht erforderlich; hier kann jede Funktion verwendet werden, die ein neues Objekt zurückgibt.

Beachten Sie, dass das Hinzufügen von Funktionen zu Objekten durch parasitäre Vererbung die Wiederverwendung von Funktionen erschweren kann, ähnlich wie beim Konstruktormuster.

Parasitäre kompositorische Vererbung

Bei der zusammengesetzten Vererbung gibt es gewisse Effizienzprobleme. Der Konstruktor der übergeordneten Klasse wird immer zweimal aufgerufen, einmal beim Erstellen des Unterklassenprototyps und einmal im Unterklassenkonstruktor. Im Wesentlichen müssen Unterklassen zur Ausführungszeit nur ihre eigenen Prototypen neu schreiben.

     Funktion inheritPrototype(Untertyp, Obertyp) {
        let prototype = Object(superType.prototype); // Objekt erstellen prototype.constructor = subType; // Erweitertes Objekt subType.prototype = prototype; // Objekt zuweisen }

Diese inheritPrototype()-Funktion implementiert die Kernlogik der parasitären Kompositionsvererbung. Diese Funktion empfängt zwei Parameter: den Konstruktor der Unterklasse und den Konstruktor der übergeordneten Klasse. Innerhalb dieser Funktion besteht der erste Schritt darin, eine Kopie des Prototyps der übergeordneten Klasse zu erstellen. Legen Sie dann die Konstruktoreigenschaft für das zurückgegebene Prototypobjekt fest, um das Problem des Verlusts des Standardkonstruktors aufgrund des Überschreibens des Prototyps zu lösen. Abschließend wird das neu erstellte Objekt dem Prototyp des Untertyps zugewiesen. Wie im folgenden Beispiel gezeigt, kann durch den Aufruf von inheritPrototype() die Subtyp-Prototypzuweisung im vorherigen Beispiel implementiert werden:

Funktion SuperType(Name) {
        dieser.name = Name;
        this.colors = ["rot", "blau", "grün"];
    }
    SuperType.prototype.sayName = Funktion () {
        konsole.log(dieser.name);
    };

    Funktion SubType(Name, Alter) {
        SuperType.call(dieser, Name);
        dieses.Alter = Alter;
    }
    erbenPrototyp(Untertyp, Supertyp);
    SubTyp.prototyp.sayAge = Funktion () {
        Konsole.log(dieses.Alter);
    };

Hier wird der SuperType-Konstruktor nur einmal aufgerufen, wodurch unnötige und ungenutzte Eigenschaften in SubType.prototype vermieden werden. Man kann also sagen, dass dieses Beispiel effizienter ist. Und die Prototypenkette bleibt weiterhin intakt.

Zusammenfassen

Dies ist das Ende dieses Artikels über die parasitäre Kompositionsvererbung in JavaScript. Weitere relevante Inhalte zur parasitären Kompositionsvererbung in JS finden Sie in früheren Artikeln auf 123WORDPRESS.COM oder in den folgenden verwandten Artikeln. Ich hoffe, dass jeder 123WORDPRESS.COM in Zukunft unterstützen wird!