CKTIS / JavaScript
Function.prototype und die Syntax von Klassenkonstruktoren
Unterscheide die Prototypkette einer Funktion von der Eigenschaft `.prototype` für Instanzen und sieh, wie `new`, `constructor` und `super()` bei der Vererbung zusammenspielen.
Version: ECMAScript 2024 and the current web platform; runtime support varies
Syntax
function C(value) {
this.value = value;
}
C.prototype.read = function () {
return this.value;
};
const instance = new C(1);
Function.prototype
Object.getPrototypeOf(C)
C.prototype
Object.getPrototypeOf(instance)
class Base {
constructor(value) {
this.value = value;
}
read() {
return this.value;
}
}
class Derived extends Base {
constructor(value) {
super(value);
this.ready = true;
}
}
const derived = new Derived(2);Function.prototype ist das eingebaute Funktionsobjekt, von dem Funktionen Methoden wie call, apply und bind erben. Es ist der direkte Prototyp einer gewöhnlichen function-Deklaration und einer Klasse ohne extends. Der Aufruf Function.prototype() gibt undefined zurück, während new Function.prototype() einen TypeError auslöst.
C.prototype ist etwas anderes: eine eigene Eigenschaft einer gewöhnlichen Konstruktorfunktion oder Klasse C. Ist ihr Wert ein Objekt, verwendet new C(...) es normalerweise als Prototyp der Instanz. Diese Verknüpfung lässt sich mit Object.getPrototypeOf(instance) prüfen. Ein Konstruktor kann stattdessen ausdrücklich ein anderes Objekt zurückgeben. Eine Pfeilfunktion wird nicht mit new verwendbar, nur weil man ihr .prototype hinzufügt.
In einer class initialisiert constructor(...) { ... } die Instanz, meist durch Zuweisungen an this. Öffentliche Instanzmethoden wie read() liegen auf C.prototype, static-Methoden auf C. Anders als bei einer gewöhnlichen Funktion löst der direkte Klassenaufruf C(...) einen TypeError aus. Bei einer gewöhnlichen Funktion lässt sich .prototype ersetzen, ohne den Prototyp bestehender Instanzen zu ändern. Bei einer Klasse ist die Eigenschaft nicht beschreibbar; das Prototypobjekt selbst bleibt aber veränderbar.
In class Derived extends Base erbt Derived von Base und Derived.prototype von Base.prototype. Rufe in einem expliziten abgeleiteten Konstruktor super(...) vor dem Zugriff auf this auf; ein früherer Zugriff löst einen ReferenceError aus. Wenn du direkt ein Objekt zurückgibst, ohne this zu verwenden, kannst du super() weglassen. Fehlt der abgeleitete Konstruktor ganz, leitet der Standardkonstruktor die Argumente weiter.
Beispiele
{
function Legacy(name) {
this.name = name;
}
Legacy.prototype.read = function () {
return this.name;
};
class Modern {
constructor(name) {
this.name = name;
}
read() {
return this.name;
}
}
const a = new Legacy('Ada');
const b = new Modern('Lin');
const prototypeOf = Object.getPrototypeOf;
const descriptor = Object.getOwnPropertyDescriptor;
console.log(`${prototypeOf(Legacy) === Function.prototype} ${prototypeOf(Modern) === Function.prototype}`);
console.log(`${prototypeOf(a) === Legacy.prototype} ${prototypeOf(b) === Modern.prototype}`);
console.log(`${a.read()} ${b.read()}`);
console.log(`${descriptor(Legacy, 'prototype').writable} ${descriptor(Modern, 'prototype').writable}`);
try {
Modern('Lin');
} catch (error) {
console.log(error.name);
}
}Ergebnis
true true true true Ada Lin true false TypeError
Führe den ganzen Block in einer Konsole aus, die `class`-Syntax unterstützt. Die ersten beiden Zeilen vergleichen die Prototypen der Konstruktoren und ihrer Instanzen; die letzte zeigt den Fehlernamen unabhängig von der Fehlermeldung.
Zugehörige Lektionen
- JavaScript · Lektion 32 · Fortgeschritten · Version: 4