Bevor Sie mit dem Code beginnen, sollten Sie klar verstehen, welchen Zweck der Vererbung und welche Vorteile bringen können. Im Allgemeinen hoffen wir bei der Gestaltung der Klasse den doppelten Code reduzieren und die Kopplung zwischen den Klassen schwächen. Es ist schwierig, sich um beide zu kümmern. Nach unserem Verständnis der Vererbung des Gesichts -Objekts wird das Erbe eine direkte, starke Kopplung bringen, aber aufgrund seiner einzigartigen Flexibilität kann JS einen starken Kopplung und einen schwachen Kopplungscode, einen hohen Effizienz und einen ineffizienten Code entwerfen. Und was Sie verwenden, hängt von der Situation ab.
Das Folgende liefert drei Vererbungsmethoden in JS: Klassenvererbung, Prototyp -Vererbung und Mischung. Hier ist eine kurze Beschreibung der Erbschaft der Klasse.
Unterrichtsform Vererbung.
Die Verwirklichung der Vererbung des JS -Typs hängt von der Prototypkette ab. Was ist die ursprüngliche Kette? Das Objekt in JS hat einen Attributprototy.
Es scheint übrigens einen Eindruck von Prototypen zu haben.
Kopieren Sie den Code -Code wie folgt:
var person = function () {
this.name = "liyatang";
};
Person.Prototype = {
// Sie können hier die grundlegende Funktion der Person bereitstellen
GetName: function () {
Kehre diesen namennamen zurück;
}
}
Wir setzen die grundlegende Funktion der Klasse in die Prototyp -Eigenschaft ein, was darauf hinweist, dass die Referenz des Personobjekts die XXX -Funktion hat.
Nach dem Verständnis des Prototyps müssen Sie verstehen, was die ursprüngliche Kette ist. Wenn ein Mitglied (Attribut oder Methode) des Besuchsobjekts, wenn das Mitglied im aktuellen Objekt nicht zu sehen ist, wird JS in dem im Prototypenattribut bezeichneten Objekt in dem bis gefundenen Objekt gefunden. Wenn es nicht gefunden wird, kehrt es zu undfinierten zurück.
Welche Eingabeaufforderungen geben uns die ursprüngliche Kette? Es ist leicht zu glauben, dass die primäre Kette bedeutet, dass eine Klasse eine andere Klasse erben kann. Dies bindet die Mitglieder der übergeordneten Klasse in die Sub -Klasse, da sie die übergeordnete Klasse finden, wenn sie nicht auf der Unterklasse gefunden werden. (Die obigen zwei Wörterabsätze sind nicht streng und nur in Easy -Overtand -Wörtern beschrieben)
Im Folgenden brauchen wir eine chinesische Klasse und müssen die Namen erben und Mitglieder der Personklasse erhalten.
Kopieren Sie den Code -Code wie folgt:
Var chinese = function (name, nation) {
// Vererbung müssen den Konstruktor der übergeordneten Klasse anrufen.
// Person kann Personalmitglieder in diesem Bereich anrufen
Person.call (this, Name);
this.nation = national;
};
Chinesisch.Prototype = Person.Prototyp;
// Es ist nicht dasselbe wie zuvor, da das Prototyp -Attribut abgedeckt ist
//Chinese.prototype = {
// GetNation: function () {{{{
// diese.nation zurückgeben;
//}
//};
// Der Weg in der Zukunft muss so hinzugefügt werden
Chinesisch.Prototype.getnation = function () {
Kehre diese .nation zurück;
};
Die Vererbungsbeziehung ist hergestellt, wir nennen sie so
Kopieren Sie den Code -Code wie folgt:
var c = neuer Chinesisch ("Liyatang", "China");
Alert (C.GetName ());
Daher ist die Erbe des Typs abgeschlossen. Ist es wirklich fertig?
Dies liegt daran, dass der obige Code chinesische. Dies wird an sich nicht toleriert, und es ist nicht der Effekt, den wir wollen.
Wir können die Kopplung in einem anderen Objekt oder einer anderen Instanz schwächen.
Kopieren Sie den Code -Code wie folgt:
//
//Chinese.prototype = new Person ();
// der zweite Typ
// var f = function () {};
//F.prototype = Person.Prototype;
//Chinese.prototype = f.Prototype;
Was sind die Unterschiede zwischen diesen beiden Methoden? Fügen Sie eine leere Funktion F im zweiten Typ hinzu, die eine Instanz der Erstellung einer übergeordneten Klasse vermeiden kann wird ausgeführt. Empfehlen Sie also die zweite Methode.
Zu diesem Zeitpunkt ist es vorbei, noch nicht! Es gibt eine Attribute der Attribute der Attribute des Objekts, die eine Referenz auf eine Funktion einer bestimmten Objektinstanz bewahren. Nach dieser Aussage sollte Chiese.Prototype.Constructor gleich Chinesisch sein, was eigentlich nicht ist.
Als die Prototyp -Kette der Chiese vor Erinnerungen eingerichtet wurde, haben wir die Person abgedeckt. Zu diesem Zeitpunkt ist Chiese.Prototype.Constructor eine Person. Wir müssen auch den folgenden Code hinzufügen
Kopieren Sie den Code -Code wie folgt:
// Es besteht keine Notwendigkeit, die IF -Bedingungen hier zu untersuchen, wobei Chinesisch kennt.
If (chinesisch.Prototype.Constructor == Object.Prototype.Constructor) {
Chinesisch.Prototype.Constructor = Chinese;
}
Verwandeln Sie sich wie folgt in den gesamten Code
Kopieren Sie den Code -Code wie folgt:
var person = function (name) {
this.name = name;
};
Person.Prototype = {
GetName: function () {
Kehre diesen namennamen zurück;
}
};
Var chinese = function (name, nation) {
Person.call (this, Name);
this.nation = national;
};
var f = function () {};
F.Prototype = Person.Prototyp;
Chinesisch.Prototype = f.Prototype;
If (chinesisch.Prototype.Constructor == Object.Prototype.Constructor) {
Chinesisch.Prototype.Constructor = Chinese;
}
Chinesisch.Prototype.getnation = function () {
Kehre diese .nation zurück;
};
var c = neuer Chinesisch ("Liyatang", "China");
Alert (C.GetName ());
Wenn Sie den Vererbungscode in eine Funktion einfügen können, ist es zweckmäßig, dass der Code wiederverwendet wird, und die letzte Sortierung des Codes ist wie folgt
Kopieren Sie den Code -Code wie folgt:
Funktion erweitert (Unterklasse, Superklasse) {{{{{{{{
var f = function () {};
F.Prototype = SuperClass.Prototype;
subclass.Prototype = new f ();
subclass.Prototype.Constructor = subclass;
subclass.superClass = superclass.prototype;
If (SuperClass.Prototype.Constructor == Object.Prototype.Constructor) {
SuperClass.Prototype.Constructor = SuperClass;
}
}
var person = function (name) {
this.name = name;
};
Person.Prototype = {
GetName: function () {
Kehre diesen namennamen zurück;
}
};
Var chinese = function (name, nation) {
Person.call (this, Name);
this.nation = national;
};
erweitern (Chinesisch, Person);
Chinesisch.Prototype.getnation = function () {
Kehre diese .nation zurück;
};
var c = neuer Chinesisch ("Liyatang", "China");
Alert (C.GetName ());
Änderung nach der Veröffentlichung:
Unter den Kommentaren im ersten Stock habe ich eine neue Sicht auf diese Erweiterungsfunktion. Es wurden zwei Methoden vorgeschlagen, um zu diskutieren, wie die ursprüngliche Kette festgelegt werden soll
Kopieren Sie den Code -Code wie folgt:
//
//Chinese.prototype = new Person ();
// der zweite Typ
// var f = function () {};
//F.prototype = Person.Prototype;
//Chinese.prototype = f.Prototype;
Die zweite Möglichkeit, die Konstruktionsfunktion der übergeordneten Klasse zu verringern, wird die Person (dieser, Name) bei der Gestaltung der chinesischen Klasse verwendet.
In der ersten Methode können Sie jedoch die Person reduzieren. Möglicherweise möchten Sie diesen Funktionscode in Erweiterung einfügen. Schreiben Sie einfach
Chinese.Prototyp = new Person () auch den gleichen Zweck: keine starke Kopplung.
Aber die Vergesslichkeit ist, dass Chinese.Prototype = new Person (); Die Antwort ist falsch! Offensichtlich muss eine neue Person () einen Namensparameter übergeben. Wir können diesen Teil der Erweiterungsfunktion nicht ausführen, daher müssen wir den Constructor für Eltern -Klassen in der chinesischen Klasse aufrufen. Dies steht auch im Einklang mit objektorientierten Ideen.
Daher wird weiterhin empfohlen, die zweite Methode zu verwenden.
Das erste Mal, dass ich auf diese Weise über technische Artikel schrieb, ist es im Grunde genommen nach meinem eigenen Denken gepflastert.