JavaScripts Prototypen-Kettenbasis der Kettenbasis

JavaScript ist keine objektorientierte Sprache und bietet keine traditionellen Vererbungsmethoden, sondern bietet eine Möglichkeit des Prototypenerbanzs unter Verwendung der von ihm bereitgestellten Prototypeigenschaften, um die Vererbung zu erreichen.

Die Prototyp -Kette ist die Hauptvermittlungsmethode in JavaScript.

Die Grundidee der Prototypkette ist: Verwenden Sie Prototypen, um einen Referenzart zu ermöglichen, um die Eigenschaften und Methoden eines anderen Referenztyps zu erben.

Beziehung zwischen Konstruktoren, Prototypen und Instanzen: Jeder Konstruktor hat ein Prototypobjekt, das Prototyp -Objekt enthält einen Zeiger auf den Konstruktor, und die Instanz enthält einen internen Zeiger auf das Prototyp -Objekt.

Wenn das Prototyp -Objekt einer Instanz eines anderen Objekts gleich ist, enthält das Prototyp -Objekt einen Zeiger auf einen anderen Prototyp, und entsprechend enthält der andere Prototyp auch einen Zeiger auf einen anderen Konstruktor.

Grundlegende Modus bei der Implementierung der Prototypkette:

 Funktion SuperType () {this.Property = true;} SuperType.Prototype.getSuperValue = Funktion () {return this.property;}; Funktion subtype () {this.subproperty = false;} // inherit supertttttype.prototype = new Supertype = new Supertype = new newntype = new newntype (); () {{return this.subProperty;}; var instance = new subtype (); alert (instance.getSuperValue ()); // WAHR

Subtyp erbt Supertype, das durch Erstellen einer Instanz von SuperType und der Zuweisung der Instanz dem Subtyp.Prototyp erreicht wird. Die Essenz der Implementierung besteht darin, das Prototypobjekt umzuschreiben und es durch eine Instanz eines neuen Typs zu ersetzen. Auf diese Weise existieren auch die Eigenschaften und Methoden, die ursprünglich in der Supertyp -Instanz existieren, auch im Subtyp.Prototyp. Fügen Sie dann eine Methode zum Subtyp hinzu.

Die Instanzbeziehung im obigen Beispiel wird wie folgt ausgedrückt:

Das obige verwendet den von Subtyp bereitgestellten Prototyp nicht standardmäßig, sondern ersetzt ihn stattdessen durch einen neuen Prototyp. Dieser neue Prototyp ist eine Instanz von SuperType. Es gibt auch einen Zeiger auf den Prototyp, der SuperType im neuen Prototyp ausführt. Infolgedessen weist die Instanz auf den Prototyp des Subtyps hin, der auf den Prototyp von SuperType hinweist. Die GetValue () -Methode befindet sich noch in SuperType.Prototyp, der Prototyp ist jedoch im Subtyp.Prototyp. Dies liegt daran, dass Eigenschaft eine Instanzeigenschaft ist und GetuperValue () eine Prototypmethode ist. Da Subtype.Prototype jetzt eine Instanz von SuperType ist, befindet sich die Eigenschaft in dieser Instanz natürlich.

Hinweis: Instance.Constructor zeigt nun auf SuperType, da der Prototyp von Subtyp auf ein anderes Objekt - SuperType -Prototyp von SuperType, und das Konstruktorattribut dieses Prototyp -Objekts auf Supertyp verweist.

Wenn Sie im Read -Modus auf ein Attribut zugreifen, wird die Instanz zunächst nach diesem Attribut gesucht. Wenn die Eigenschaft nicht gefunden wird. Dann wird die Suche nach dem Prototyp der Instanz fortgesetzt. Wenn die Vererbung durch die Prototypkette erreicht wird, kann sich der Suchprozess entlang der Prototypkette weiter nach oben bewegen.

Standardprototyp

Alle Referenztypen erben standardmäßig das Objekt, und diese Vererbung wird auch über die Prototypkette implementiert. Der Standardprototyp aller Funktionen ist eine Instanz des Objekts. Daher enthält der Standardprototyp einen internen Zeiger auf Object.Prototyp. Aus diesem Grund erben benutzerdefinierte Typen Methoden wie ToString (), ValueOf () usw.

Komplette Prototypkette:

Im obigen Vererbungssystem erbt Subtyp SuperType und Supertype -Objekt. Wenn Instance.toString () aufgerufen wird, wird die in Object gespeicherte Methode tatsächlich aufgerufen.

Bestimmen Sie die Beziehung zwischen Instanz und Prototyp

Es gibt zwei Möglichkeiten, die Beziehung zwischen einem Prototyp und einer Instanz zu bestimmen:

Verwenden Sie den Instanz des Bedieners

 ALERT (Instanzinstanz von Objekt); ALERT (Instanzinstanz von SuperType); ALERT (Instanzinstanz von Subtyp);

Aufgrund der Beziehung zwischen der Prototyp -Kette gibt alle oben genannten die wahren wahr.

Verwenden Sie die isPrototypeof () -Methode

 alert (Object.Prototype.riprototypeof (Instanz)); Alert (SuperType.Prototype.riprototypeof (Instance)); alert (subtyp.Prototype.riprototypeof (Instanz)); alert (subtyp.Prototype.riprototypeof (Instanz));

Definieren Sie die Methode sorgfältig

Der Code zum Hinzufügen von Methoden zum Prototyp muss nach der Anweisung platziert werden, die den Prototyp ersetzt.

 function SuperType() {this.property = true;}SuperType.prototype.getSuperValue = function () {return this.property;};function SubType() {this.subproperty = false;}SuperType.prototype = new SuperType();// Add method SubType.prototype.getSubValue = function () {return this.subProperty;}; // Überschreiben Sie die Methode subtyp.prototype.getSuperValue = function () {return this.subProperty;}; // überschreiben Sie die Methode subtype.prototype // FALSCH

Im obigen Beispiel muss angemerkt werden, dass nach dem Ersetzen des Prototyps durch die Instanz von SuperType diese beiden Methoden definiert werden.

Wenn Sie durch die Erben durch die Prototyp -Kette nicht das Objektliteral verwenden, können Sie eine Prototypmethode erstellen. Denn dies wird die Prototypkette umschreiben:

 Funktion SuperType () {this.property = true;} SuperType.Prototype.getSuperValue = Funktion () {return this.property;}; Funktion subtype () {this.subproperty = false;} // inherit SuperType -Literatur. Ungültiger subtyp.Prototype = {getUbUbValue: function () {return this.subProperty;}, einigeothermeThod: function () {return false;}}; var instance = new Subtyp (); alert (Instance.getSuperValue ()); // Fehler

Das obige Beispiel weist dem Prototyp die Instanz von SuperType zu und ersetzt dann den Prototyp durch ein Objektliteral. Der aktuelle Prototyp enthält eine Instanz des Objekts, keine Instanz von SuperType, und es gibt keine Beziehung zwischen Subtyp und Supertyp.

Prototyp -Kettenproblem

Wie bereits erwähnt, werden die Prototypattribute, die Referenztypen enthalten, von allen Instanzen gemeinsam genutzt. Aus diesem Grund sollten Attribute eher im Konstruktor als im Prototypobjekt definiert werden.

 Funktion SuperType () {this.colors = ["Red", "Blue", "Green"];} Funktion subtyp () {} subtyp.Prototype = new SuperType (); var instance1 = new subtyp (); Instance1.colors.push ("schwarz"); // "rot", "blau", "grün", "schwarz" var instance2 = new subtype (); alert (instance2.colors); // "rot", "blau", "grün", "schwarz"

Im obigen Beispiel wird eine Farb -Eigenschaft im Supertyp -Konstruktor definiert, das ein Array enthält, und jede Instanz von SuperType hat eine Farbeneigenschaft, die ein eigenes Array enthält. Nachdem Subtyp SuperType durch die Prototypkette erbt, wird Subtyp.Prototyp zu einer Instanz von SuperType, sodass es auch ein eigenes Farbenattribut hat. Alle Fälle von Subtyp teilen sich jedoch diese Eigenschaft mit Farben.

Ein weiteres Problem ist, dass es keine Möglichkeit gibt, Parameter an den Superklassenkonstruktor weiterzugeben, ohne alle Objektinstanzen zu beeinflussen.

Das obige ist die relevante Kenntnis von JavaScript basierend auf der Prototyp -Kette -Vererbung, die der Editor Ihnen vorgestellt hat. Ich hoffe, es wird Ihnen hilfreich sein. Wenn Sie Fragen haben, hinterlassen Sie mir bitte eine Nachricht und der Editor wird Ihnen rechtzeitig antworten. Vielen Dank für Ihre Unterstützung auf der Wulin.com -Website!