GeneratorFunction.prototype.prototype — Eigenschaft · JavaScript-Referenz

Signatur

GeneratorFunction.prototype.prototype

Beschreibung

GeneratorFunction.prototype.prototype ist das eingebaute Objekt, das in der Spezifikation %GeneratorPrototype% heißt und oft als Generator.prototype bezeichnet wird. Darauf liegen die Methoden, die jedes Generator-Objekt hat: next(), return() und throw(). Außerdem gehört dazu das Symbol Symbol.toStringTag mit dem Wert "Generator".

Jede Generatorfunktion (function* name() {}) bekommt ein eigenes prototype-Objekt, dessen Prototyp GeneratorFunction.prototype.prototype ist. Beim Aufruf einer Generatorfunktion entsteht ein Generator-Objekt, das von name.prototype erbt. So ergibt sich diese Prototypkette:

generatorObjekt → name.prototype → GeneratorFunction.prototype.prototype → Iterator.prototype → Object.prototype

Im Alltag braucht man diese Eigenschaft selten direkt. Nützlich ist sie für Metaprogrammierung, zum Prüfen, ob ein Objekt ein echter Generator ist, und zum Verständnis der Vererbung. Der Konstruktor GeneratorFunction ist nicht global verfügbar. Man kommt über Object.getPrototypeOf(function* () {}).constructor an ihn heran.

Rückgabewert

Typ

Object

Beschreibung

Das gemeinsame Prototyp-Objekt aller Generatoren (%GeneratorPrototype%) mit den Methoden next, return und throw. Die Eigenschaft ist nicht schreibbar und nicht aufzählbar, aber konfigurierbar.

Beispiele

An GeneratorFunction und den gemeinsamen Prototyp kommen

// GeneratorFunction ist nicht global – so erreicht man den Konstruktor
const GeneratorFunction = Object.getPrototypeOf(function* () {}).constructor;
const GeneratorPrototype = GeneratorFunction.prototype.prototype;

console.log(Object.getOwnPropertyNames(GeneratorPrototype));
console.log(GeneratorPrototype[Symbol.toStringTag]);

[ 'constructor', 'next', 'return', 'throw' ] Generator

Die Prototypkette eines Generator-Objekts prüfen

const GeneratorFunction = Object.getPrototypeOf(function* () {}).constructor;

function* zaehler(max) {
  for (let i = 1; i <= max; i++) yield i;
}

const it = zaehler(3);

console.log(Object.getPrototypeOf(it) === zaehler.prototype);
console.log(Object.getPrototypeOf(zaehler.prototype) === GeneratorFunction.prototype.prototype);
console.log(it.next === GeneratorFunction.prototype.prototype.next);

true true true

Echte Generator-Objekte erkennen

const GeneratorPrototype = Object.getPrototypeOf(function* () {}).constructor.prototype.prototype;

const istGenerator = (wert) =>
  wert !== null && typeof wert === 'object' && GeneratorPrototype.isPrototypeOf(wert);

function* ids() { yield 'a'; }
const eigenerIterator = { next: () => ({ done: true, value: undefined }) };

console.log(istGenerator(ids()));
console.log(istGenerator(eigenerIterator));
console.log(istGenerator([1, 2].values()));

true false false

Eigenschafts-Deskriptor ansehen

const GeneratorFunction = Object.getPrototypeOf(function* () {}).constructor;
const { writable, enumerable, configurable } =
  Object.getOwnPropertyDescriptor(GeneratorFunction.prototype, 'prototype');

console.log({ writable, enumerable, configurable });

{ writable: false, enumerable: false, configurable: true }

// Wichtig · Fallstricke

Keine globale Variable: Weder GeneratorFunction noch Generator gibt es als globale Bezeichner. Man erreicht sie nur über Object.getPrototypeOf(...).
Nicht mit genFn.prototype verwechseln: Jede Generatorfunktion hat ihr eigenes prototype-Objekt. Nur dessen Prototyp ist das gemeinsame GeneratorFunction.prototype.prototype. Anders als bei normalen Funktionen hat genFn.prototype keine Eigenschaft constructor. Generatorfunktionen lassen sich außerdem nicht mit new aufrufen (das löst einen TypeError aus).
Die Eigenschaft ist schreibgeschützt: Eine Zuweisung an GeneratorFunction.prototype.prototype wird im nicht-strikten Modus stillschweigend ignoriert. Im strikten Modus löst sie einen TypeError aus.
Vorsicht beim Monkey-Patching: Methoden, die man auf diesem Objekt ergänzt, gelten für alle Generatoren im gesamten Realm, auch für die in Fremdbibliotheken. Für Hilfsfunktionen wie map oder take sollte man besser die Iterator-Helfer auf Iterator.prototype verwenden (ES2025, in modernen Browsern und ab Node.js 22 verfügbar).
Realm-Grenzen: Generatoren aus iframes oder vm-Kontexten haben ihren eigenen %GeneratorPrototype%. Eine Prüfung mit isPrototypeOf schlägt bei ihnen deshalb fehl.
Async-Generatoren verwenden ein eigenes Objekt: AsyncGeneratorFunction.prototype.prototype.
Browser-Unterstützung: Alle modernen Browser und Node.js unterstützen die Eigenschaft (Baseline seit ES2015).

Siehe auch

GeneratorFunction Generator Generator.prototype.next() Generator.prototype.return() Generator.prototype.throw() AsyncGeneratorFunction.prototype.prototype Object.getPrototypeOf()