Das Konzept des JS -Vererbings
Die folgenden zwei in JS üblicherweise verwendeten Vererbungsmethoden:
Prototyp -Kettenvererbung (Vererbung zwischen Objekten)
Klassische Vererbung (Vererbung zwischen Konstruktoren)
Da JS keine wirklich objektorientierte Sprache wie Java ist, ist JS objektbasiert und hat kein Konzept von Klassen. Wenn Sie die Vererbung implementieren möchten, können Sie daher den Prototyp -Prototypenmechanismus von JS oder die Antragsmethoden zur Implementierung verwenden
In einer objektorientierten Sprache verwenden wir Klassen, um ein benutzerdefiniertes Objekt zu erstellen. Alles in JS ist jedoch ein Objekt. Mit welcher Methode kann ein benutzerdefiniertes Objekt erstellt werden? Dies erfordert den JS -Prototyp:
Wir können den Prototyp einfach als Vorlage betrachten. Die neu erstellten benutzerdefinierten Objekte sind eine Kopie dieser Vorlage (Prototype) (eigentlich keine Kopie, sondern ein Link, aber diese Art von Link ist unsichtbar. Es gibt einen unsichtbaren __Proto__ -Zeiger im neu instanziierten Objekt, der auf das Prototyp -Objekt hinweist).
JS kann die Funktionen von Klassen durch Konstruktoren und Prototypen simulieren und implementieren. Darüber hinaus wird auch die Implementierung des JS -Vererbens erreicht, indem sich auf Prototyp -Ketten stützt.
Prototyp -Vererbung und Klassenvererbung
Das klassische Vererbung ist der Ruf eines Supertyp -Konstruktors im Subtyp -Konstruktor.
Strenge Klassenvererbung ist nicht sehr häufig und wird im Allgemeinen in Kombination verwendet:
Die Codekopie lautet wie folgt:
Funktion super () {
this.colors = ["rot", "blau"];
}
Funktion sub () {
Super.Call (dies);
}
Der Prototyp -Vererbung besteht darin, mit Hilfe vorhandener Objekte ein neues Objekt zu erstellen und den Prototyp der Unterklasse auf die übergeordnete Klasse zu richten, was dem Hinzufügen der Prototypkette der übergeordneten Klasse entspricht.
Prototyp -Kettenvererbung
Damit eine untergeordnete Klasse die Eigenschaften der übergeordneten Klasse (einschließlich Methoden) erben, ist ein Konstruktor zuerst erforderlich, um zu definieren. Weisen Sie dem Prototyp des Konstruktors eine neue Instanz der übergeordneten Klasse zu. Der Code ist wie folgt:
Die Codekopie lautet wie folgt:
<Script>
Funktion Eltern () {
this.name = 'mike';
}
Funktion Child () {
this.age = 12;
}
Child.Prototype = new Parent (); // Child erbt Eltern und bildet eine Kette durch den Prototyp.
var test = new Child ();
alarm (test.age);
Alert (test.name); // Erbgreiger Attribute erhalten
// Erben Sie weiterhin die Prototypkette
Funktion Bruder () {// Bruder Konstrukt
this.gewicht = 60;
}
Bruder.Prototyp = new Child (); // Weitere Prototypenkettenvererbung fortsetzen
var brother = neuer Bruder ();
Alert (Bruder.Name); // Erben Eltern und Kind, Mike taucht auf
Alarm (Bruder.age); // Pop 12
</script>
In der obigen Prototyp -Kette -Vererbung fehlt immer noch ein Glied, dh Objekt, und alle Konstruktoren werden vom Objekt vererbt. Das Erben von Objekten wird automatisch abgeschlossen und erfordert keine manuelle Erbschaft. Wie ist ihre untergeordnete Beziehung?
Bestimmen Sie die Beziehung zwischen Prototyp und Instanz
Es gibt zwei Möglichkeiten, die Beziehung zwischen einem Prototyp und einer Instanz zu bestimmen. Operatorinstanz und isprototypeof () Methoden:
Die Codekopie lautet wie folgt:
Alert (Bruderinstanz von Objekt) // wahr
Alarm (Testinstanz des Bruders); // Falsch, Test ist die Superklasse des Bruders
Alarm (Bruderinstanz des Kindes); // wahr
Alarm (Bruderinstanz des Elternteils); // wahr
Solange es sich um einen Prototyp handelt, der in der Prototypkette erscheint, kann es als Prototyp der von der Prototypkette abgeleiteten Instanz sein. Daher wird die ISPrototypeof () -Methode auch true zurückgegeben.
In JS wird die ererbte Funktion als Supertyp (übergeordnete Klasse, Basisklasse und auch) bezeichnet, und die ererbte Funktion wird als Subtyp (Unterklasse, abgeleitete Klasse) bezeichnet. Die Verwendung von Prototypenvereritanz beinhaltet hauptsächlich zwei Probleme:
Erstens wird die wörtliche Umschreibung von Prototypen die Beziehung brechen, den Prototyp des Referenztyps verwenden und der Subtyp kann keine Parameter an den Supertyp übergeben.
Die Pseudoklasse löst das Problem der Referenzfreigabe und der Supertypen können keine Argumente übergeben. Wir können die Technologie "Ausleihenkonstruktor" verwenden.
Ausleihenkonstruktor (klassischer Vererbung)
Die Codekopie lautet wie folgt:
<Script>
Funktion Eltern (Alter) {
this.name = ['mike', 'Jack', 'Smith'];
this.age = Alter;
}
Funktion Kind (Alter) {
Parent.call (this, Alter);
}
var test = neues Kind (21);
Alarm (test.age); // 21
Alert (test.name); // Mike, Jack, Smith
test.name.push ('bill');
Alert (test.name); // Mike, Jack, Smith, Bill
</script>
Obwohl die Ausleihkonstruktoren die beiden Probleme ohne Prototypen gelöst haben, gibt es keine Möglichkeit, wieder zuverwenden. Daher benötigen wir ein Prototyp -Ketten- + Kredit -Konstruktor -Muster. Dieses Muster wird als Kombinationsvererbung bezeichnet.
Kombinationsvererbung
Die Codekopie lautet wie folgt:
<Script>
Funktion Eltern (Alter) {
this.name = ['mike', 'Jack', 'Smith'];
this.age = Alter;
}
Parent.prototype.run = function () {
return this.name + 'sind beide' + this.age;
};
Funktion Kind (Alter) {
Parent.call (this, Alter); // Objekt ist es, Parameter an Supertypes zu sein und übergeben
}
Child.Prototype = new Parent (); // Prototyp -Kette -Vererbung
var test = neues Kind (21); // Neue Eltern schreiben (21) ist in Ordnung
Alert (test.run ()); // Mike, Jack, Smith sind beide21
</script>
Die Kombinationsvererbung ist eine relativ häufig verwendete Vererbungsmethode. Die Idee dahinter besteht darin, die Prototyp -Kette zu verwenden, um die Vererbung von Prototypeigenschaften und -methoden zu implementieren und die Vererbung von Instanzeigenschaften durch Kreditkonstruktoren zu implementieren. Auf diese Weise wird die Funktionsmultiplexierung durch Definieren von Methoden im Prototyp und der Sicherstellung, dass jede Instanz ihre eigenen Eigenschaften hat.
Verwendung von Call (): Rufen Sie eine Methode eines Objekts auf und ersetzen Sie das aktuelle Objekt durch ein anderes Objekt.
Die Codekopie lautet wie folgt:
Rufen Sie an ([thisobj [, arg1 [, arg2 [, .Argn]]]])
Prototyp -Vererbung
Diese Art, die Erstellung neuer Objekte auf der Grundlage vorhandener Objekte ohne Erstellen benutzerdefinierter Typen zu erben, wird als Prototyp -Vererbung bezeichnet
Die Codekopie lautet wie folgt:
<Script>
Funktion obj (o) {
Funktion f () {}
F.Prototyp = o;
Neue f () zurückgeben;
}
var box = {
Name: 'Trigkit4',
arr: ['Bruder', 'Schwester', 'Baba']
};
var b1 = obj (box);
Alert (B1.Name); // trigkit4
B1.Name = 'Mike';
Alarm (B1.Name); // Mike
Alert (B1.arr); // Bruder, Schwester, Baba
B1.arr.push ('Eltern');
Alert (B1.arr); // Bruder, Schwester, Baba, Eltern
var b2 = obj (box);
Alert (B2.Name); // trigkit4
Alert (B2.arr); // Bruder, Schwester, Baba, Eltern
</script>
Der Prototyp -Vererbung erstellt zunächst einen temporären Konstruktor innerhalb der OBJ () -Funktion, verwendet dann das übergebene Objekt als Prototyp des Konstruktors und gibt schließlich eine neue Instanz dieses temporären Typs zurück.
Parasitäres Vererbung
Diese Vererbungsmethode kombiniert das Prototyp + Fabrikmodell mit dem Zweck des Erstellungsprozesses der Kapselung.
Die Codekopie lautet wie folgt:
<Script>
Funktion create (o) {
var f = obj (o);
f.run = function () {
Geben Sie dies zurück.
};
Rückkehr f;
}
</script>
Kleine Probleme mit der Kombinationsvererbe
Die Kombinationsvererbung ist der am häufigsten verwendete Vererbungsmodus in JS, aber der Supertyp der kombinierten Vererbung wird während der Verwendung zweimal aufgerufen. Einmal beim Erstellen eines Subtyps und der andere befindet sich im Subtyp -Konstruktor.
Die Codekopie lautet wie folgt:
<Script>
Funktion Eltern (Name) {
this.name = name;
this.arr = ['Bruder', 'Schwester', 'Eltern'];
}
Parent.prototype.run = function () {
kehre diesen namennamen zurück;
};
Funktion Kind (Name, Alter) {
Parent.call (this, Alter); // der zweite Anruf
this.age = Alter;
}
Child.Prototype = new Parent (); // Der erste Anruf
</script>
Der obige Code ist die vorherige Kombinationsvererbung, daher löst die parasitäre Kombination Vererbung das Problem von zwei Aufrufen.
Parasitäre Kombinationserbranz
Die Codekopie lautet wie folgt:
<Script>
Funktion obj (o) {
Funktion f () {}
F.Prototyp = o;
Neue f () zurückgeben;
}
Funktion create (übergeordnet, test) {
var f = obj (parent.prototype); // ein Objekt erstellen
F.Constructor = Test; // erweitertes Objekt
}
Funktion Eltern (Name) {
this.name = name;
this.arr = ['Bruder', 'Schwester', 'Eltern'];
}
Parent.prototype.run = function () {
kehre diesen namennamen zurück;
};
Funktion Kind (Name, Alter) {
Parent.call (this, name);
this.age = Alter;
}
InheritPrototype (Elternteil, Kind); // Erbeerung wird hier realisiert
var test = neues Kind ('trigkit4', 21);
test.arr.push ('Neffe');
Alert (test.arr); //
ALERT (test.run ()); // Nur die Methode wird gemeinsam genutzt
var test2 = neues Kind ('Jack', 22);
Alert (test2.arr); // das Zitierproblem lösen
</script>
Rufen Sie an und bewerben Sie sich
Die globalen Funktionen gelten und Anrufe können verwendet werden, um das Zeigen in der Funktion wie folgt zu ändern:
Die Codekopie lautet wie folgt:
// eine globale Funktion definieren
Funktion foo () {
console.log (this.fruit);
}
// eine globale Variable definieren
var fruit = "Apfel";
// Ein Objekt anpassen
var pack = {
Frucht: "Orange"
};
// äquivalent zu window.foo ();
foo.apply (Fenster); // "Apple", das entspricht dem Fenster
// this === Pack in foo
foo.apply (pack); // "orange"