Object.prototype.constructor — Eigenschaft · JavaScript-Referenz

Signatur

Object.prototype.constructor

Beschreibung

Die Eigenschaft constructor liegt normalerweise nicht direkt auf der Instanz, sondern auf dem Prototyp ihres Konstruktors. Jede gewöhnliche Funktion (und jede Klasse) bekommt beim Anlegen ein prototype-Objekt, dessen constructor auf die Funktion selbst zurückverweist. Instanzen erben diese Eigenschaft über die Prototypkette: new Foo().constructor === Foo.

Typische Einsatzzwecke sind: aus einer vorhandenen Instanz eine neue Instanz desselben Typs erzeugen (new obj.constructor()), den Klassennamen für Logs oder Debugging auslesen (obj.constructor.name) und in generischem Code (Klonen, Serialisieren) den Typ eines Objekts bestimmen.

Wichtig: constructor ist eine ganz normale, beschreibbare und nicht aufzählbare Dateneigenschaft. Sie lässt sich überschreiben oder geht verloren, wenn man prototype komplett ersetzt. Für verlässliche Typprüfungen eignen sich daher instanceof, Array.isArray() oder Object.prototype.toString.call() besser.

Primitive Werte wie 1 oder "abc" werden beim Zugriff kurzzeitig in ihre Wrapper-Objekte umgewandelt, daher liefert (1).constructor die Funktion Number. Objekte ohne Prototyp (Object.create(null)) besitzen keine constructor-Eigenschaft.

Rückgabewert

Typ

Function | undefined

Beschreibung

Eine Referenz auf die Konstruktorfunktion (nicht deren Namen als String). undefined, wenn in der Prototypkette keine constructor-Eigenschaft existiert, z. B. bei Object.create(null).

Beispiele

Konstruktor eingebauter Typen auslesen

console.log({}.constructor === Object);
console.log([].constructor === Array);
console.log((42).constructor === Number);
console.log('text'.constructor.name);
console.log(Object.create(null).constructor);

true true true String undefined

Neue Instanz desselben Typs erzeugen

class Vector {
  constructor(x = 0, y = 0) { this.x = x; this.y = y; }
  add(other) {
    // Funktioniert auch für Unterklassen, weil this.constructor dynamisch ist
    return new this.constructor(this.x + other.x, this.y + other.y);
  }
}
class Vector2D extends Vector {}

const v = new Vector2D(1, 2).add(new Vector2D(3, 4));
console.log(v.constructor.name, v.x, v.y);
console.log(v instanceof Vector2D);

Vector2D 4 6 true

Verlorener constructor nach Ersetzen von prototype

function Person(name) { this.name = name; }

// Prototyp komplett ersetzt – constructor zeigt jetzt auf Object!
Person.prototype = {
  greet() { return `Hallo, ${this.name}`; }
};
const p = new Person('Anna');
console.log(p.constructor === Person); // false
console.log(p.constructor === Object); // true

// Korrekt wiederherstellen (nicht aufzählbar wie das Original)
Object.defineProperty(Person.prototype, 'constructor', {
  value: Person,
  writable: true,
  configurable: true,
  enumerable: false
});
console.log(new Person('Ben').constructor === Person);

false true true

Typname für Logging ermitteln

const typeName = (value) =>
  value == null ? String(value) : value.constructor?.name ?? 'Object (ohne Prototyp)';

console.log(typeName(new Map()));
console.log(typeName(new Date()));
console.log(typeName(null));
console.log(typeName(Object.create(null)));

Map Date null Object (ohne Prototyp)

// Wichtig · Fallstricke

Nicht fälschungssicher: constructor ist beschreibbar – obj.constructor = Array ist erlaubt. Für Typprüfungen besser instanceof, Array.isArray() oder Object.prototype.toString.call(obj) verwenden.
Vererbung mit Funktionen: Nach Child.prototype = Object.create(Parent.prototype) zeigt constructor auf Parent. Man muss ihn manuell (am besten per Object.defineProperty, nicht aufzählbar) auf Child zurücksetzen. Bei class … extends passiert das automatisch.
Realms: Objekte aus einem anderen iframe oder Worker haben einen anderen Array- bzw. Object-Konstruktor, arr.constructor === Array ist dann false.
null/undefined: Zugriff auf constructor wirft einen TypeError; optionale Verkettung (value?.constructor) hilft.
Minifizierung: constructor.name kann durch Minifizierer verändert werden – nicht für Programmlogik verwenden.
Eingebaute Methoden wie Array.prototype.map ermitteln über constructor[Symbol.species] den Typ des Ergebnisses; ein manipulierter constructor kann dieses Verhalten beeinflussen.

Siehe auch

instanceof Object.getPrototypeOf() Object.create() Function.prototype.prototype Function.prototype.name Symbol.species class