Die Vererbung in JavaScript ist ziemlich seltsam. Es kann keine Schnittstellenvererbung implementieren und kann sich nur auf Prototypenvererbung verlassen.
Prototypkette
Ein Prototyp ist ein Objekt. Die durch den Konstruktor erstellte Instanz hat einen Zeiger auf den Prototyp, um die Eigenschaften und Methoden des Prototyps zu erhalten. Auf diese Weise hat das Instanzobjekt die Attributmethode des Konstruktors und die Attributmethode des Prototyps und weist dann den Prototyp des Konstruktors an, der zu dieser Instanz vererbt werden muss, damit alle Attributmethoden der Instanz geerbt werden können.
Siehe den folgenden Demo -Code:
// Die Superklasse deklarieren, relevante Eigenschaften und Methoden durch Konstruktoren und Prototypen Funktion super () {this.property = true;} Super.Prototype.getSuperValue () () {return this.property;}; // Declare the Constructor -Funktion Subttype () thttclass theSubproperty = Fastroperty = Fastroperty = Fastroperty = Fastroperty = Fastroperty = Fastroperty = Fishtroperty = Fishtroperty, hinzufügen. Superklasse und erhalten Sie alles in den superklasse subtyp.prototype = new Super (); subtyp.Prototype.Constructor = subtyp; subtyp.Prototype.getSubvalue = Funktion () {return diese SubProperty;}; // Erstellen eines Objekts, das in einer Unterklasse testet, um zu testen. console.log (instance.getSuperValue ());Der Standardprototyp aller Funktionen ist eine Instanz des Objekts, sodass der Standardprototyp einen internen Zeiger auf Object.Prototyp enthält.
Verwenden Sie InstanceOF und iSprototypeof, um die Beziehung zwischen Prototypen und Instanzen zu bestimmen:
Instanzinstanz des Objekts; Object.Prototype.riprototypeof (Instanz);
Bei der Verwendung von Prototyp -Ketten müssen Sie die Methode sorgfältig definieren. Unterklassen müssen eine Methode oder Erweiterung von SuperType umschreiben und nach der Anweisung platziert werden, die den Prototyp ersetzt, damit sie wirksam werden kann. Bei der Erben durch eine Prototypkette können Sie außerdem Objektliterale nicht verwenden, um eine Prototypmethode zu erstellen, die die Prototyp -Kette überschreibt:
...... subtype.prototype = new Super (); subtype.prototype = {....};Dies ersetzt den Zeiger, um auf das neue Objekt zu verweisen und die Prototypkette neu zu schreiben.
Die Vererbungsmethode von Prototypketten ist fehlerhaft und es gibt zwei Hauptprobleme:
1. Aus einem Prototyp, der den Wert des Referenztyps enthält, wird er von allen Instanzen gemeinsam genutzt.
Wie im vorherigen Artikel erwähnt, werden die Prototypattribute, die Referenztypwerte enthalten, von allen Instanzen gemeinsam genutzt. Eine Instanz wird geändert und die anderen Instanzen werden entsprechend geändert. Daher müssen die Attribute im Konstruktor definiert werden. Wenn die Prototyp -Kette erbt, unabhängig davon, ob die Attribute in der Superklasse im Konstruktor oder im Prototyp definiert sind, werden alle zu Instanzobjekten und werden durch Unterklassen vererbt, wodurch sich die Fälle der Unterklasse auswirken.
2. Beim Erstellen einer Instanz eines Subtyps können Parameter nicht an den Supertyp -Konstruktor übergeben werden.
Die Vererbung der Prototypkette zeigt den Subklass -Prototyp direkt auf die Instanz der Superklasse, und zu diesem Zeitpunkt können Parameter an die Superklasse übergeben werden. Wenn jedoch eine Unterklasse eine Instanz erstellt, kann sie nur Parameter an den Konstruktor der Unterklasse übergeben, jedoch nicht an den Konstruktor der Superklasse.
Daher werden in praktischen Anwendungen Prototypketten selten allein verwendet.
Einige verwandte Codepraktiken
Identifizieren Sie ein Prototypattribut
Funktion hasPrototypeproperty (Objekt, Name) {Rückgabe Name in Object &&! Object.hasownProperty (Name);}Verwenden von Prototypobjekten in Konstruktoren
Funktionsperson (Name) {this.name = name;} Person.Prototype = {Konstruktor: Person, sayName: function () {console.log (this.name); }, toString: function () {}}; var person1 = new Person ('nicholas'); var person2 = new Person ('Greg); console.log (Person1 -Instanz von Person); // trueconsole.log (Person1.Constructor === Person); // trueconsole.log (Person1.Constructor === Person); // trueconsole.log (Person1.Constructor === Objekt); // falseconsole.log (Person2 -Instanz von Person); // trueconsole.log (Person2.Constructor === Person); // Trueconsole.log (Person2.Constructor === Objekt); // FALSCHObjektvererbung
var person1 = {name: 'nicholas', sayname: function () {console.log (this.name); }}; var person2 = Object.create (Person1, {Name: {konfigurierbar: true, aufzählbar: true, value: 'Greg', beschreibbar: true}}); person1.sayname (); // Nicholasperson2.SayName (); // Gregconsole.log (Person1.hasownProperty ('SayName')); // TrueConsole.log (Person1.IsPropertyof (Person2)); // trueconsole.log (Person2.hasownProperty ('SayName')); // FALSCHModulmodus
var person = (function () {var age = 25; Funktion getage () {return ay;} function Growolder () {alter ++;} return {name: 'nicholas', getage: getage, Growolder: Growolder};} ());Bereichskonstruktor
Funktionsperson (Name) {this.name = name;} person.Prototype.sayname = function () {console.log (this.name);}; var person1 = person ('nicholas'); console.log (person1111Of person); // falseconsole.log (typeof Person1); // undefinedConsole.log (Name); // Nicholas