constructor - JavaScript | MDN

Seitenleiste umschalten

Farbschema

Systemeinstellung
Hell
Dunkel

Deutsch

Sprache merken Mehr erfahren

constructor

Baseline Weitgehend verfügbar

Diese Funktion ist gut etabliert und funktioniert auf vielen Geräten und in vielen Browserversionen. Sie ist seit März 2016 browserübergreifend verfügbar.

Die constructor-Methode ist eine spezielle Methode einer Klasse zur Erzeugung und Initialisierung einer Objektinstanz dieser Klasse.

Hinweis: Diese Seite stellt die constructor-Syntax vor. Informationen zur constructor-Eigenschaft, die in allen Objekten vorhanden ist, finden Sie unter Object.prototype.constructor.

In diesem Artikel

Probieren Sie es aus

class Polygon {
  constructor() {
    this.name = "Polygon";
  }
}

const poly = new Polygon();

console.log(poly.name);
// Expected output: "Polygon"

Syntax

js
constructor() { /* … */ }
constructor(argument0) { /* … */ }
constructor(argument0, argument1) { /* … */ }
constructor(argument0, argument1, /* …, */ argumentN) { /* … */ }

Es gibt einige zusätzliche Syntaxbeschränkungen:

Eine Klassenmethode namens constructor kann kein getter, setter, async oder generator sein.
Eine Klasse kann nicht mehr als eine constructor-Methode haben.

Ein Konstruktor ermöglicht es Ihnen, jede benutzerdefinierte Initialisierung bereitzustellen, die durchgeführt werden muss, bevor andere Methoden auf einem instanziierten Objekt aufgerufen werden können.

js
class Person {
  constructor(name) {
    this.name = name;
  }

  introduce() {
    console.log(`Hello, my name is ${this.name}`);
  }
}

const otto = new Person("Otto");

otto.introduce(); // Hello, my name is Otto

Wenn Sie keinen eigenen Konstruktor bereitstellen, wird ein Standardkonstruktor für Sie bereitgestellt. Wenn Ihre Klasse eine Basisklasse ist, ist der Standardkonstruktor leer:

constructor() {}

Wenn Ihre Klasse eine abgeleitete Klasse ist, ruft der Standardkonstruktor den übergeordneten Konstruktor auf und gibt alle bereitgestellten Argumente weiter:

js
constructor(...args) {
  super(...args);
}

Hinweis: Der Unterschied zwischen einem expliziten Konstruktor wie dem oben genannten und dem Standardkonstruktor besteht darin, dass letzterer tatsächlich nicht den Array-Iterator durch Argumentverteilung aufruft.

Das ermöglicht, dass der folgende Code funktioniert:

js
class ValidationError extends Error {
  printCustomerMessage() {
    return `Validation failed :-( (details: ${this.message})`;
  }
}

try {
  throw new ValidationError("Not a valid phone number");
} catch (error) {
  if (error instanceof ValidationError) {
    console.log(error.name); // This is Error instead of ValidationError!
    console.log(error.printCustomerMessage());
  } else {
    console.log("Unknown error", error);
    throw error;
  }
}

Die ValidationError-Klasse benötigt keinen expliziten Konstruktor, da sie keine benutzerdefinierte Initialisierung durchführen muss. Der Standardkonstruktor kümmert sich dann um die Initialisierung des übergeordneten Error-Objekts mit dem gegebenen Argument.

Wenn Sie jedoch einen eigenen Konstruktor bereitstellen und Ihre Klasse von einer übergeordneten Klasse abgeleitet ist, müssen Sie den Konstruktor der übergeordneten Klasse explizit mit super() aufrufen. Zum Beispiel:

js
class ValidationError extends Error {
  constructor(message) {
    super(message); // call parent class constructor
    this.name = "ValidationError";
    this.code = "42";
  }

  printCustomerMessage() {
    return `Validation failed :-( (details: ${this.message}, code: ${this.code})`;
  }
}

try {
  throw new ValidationError("Not a valid phone number");
} catch (error) {
  if (error instanceof ValidationError) {
    console.log(error.name); // Now this is ValidationError!
    console.log(error.printCustomerMessage());
  } else {
    console.log("Unknown error", error);
    throw error;
  }
}

Die Verwendung von new auf einer Klasse durchläuft die folgenden Schritte:

(Wenn es sich um eine abgeleitete Klasse handelt) Der Konstruktor-Körper vor dem super()-Aufruf wird ausgewertet. Dieser Teil sollte auf this nicht zugreifen, da es noch nicht initialisiert ist.
(Wenn es sich um eine abgeleitete Klasse handelt) Der super()-Aufruf wird ausgewertet, was die übergeordnete Klasse durch denselben Prozess initialisiert.
Die Felder der aktuellen Klasse werden initialisiert.
Der Konstruktor-Körper nach dem super()-Aufruf (oder der gesamte Körper, wenn es sich um eine Basisklasse handelt) wird ausgewertet.

Innerhalb des Konstruktor-Körpers können Sie auf das erstellte Objekt über this zugreifen und auf die Klasse, die mit new aufgerufen wird, durch new.target zugreifen. Beachten Sie, dass Methoden (einschließlich Gettern und Settern) und die Prototypenkette bereits auf this initialisiert sind, bevor der Konstruktor ausgeführt wird. Dies bedeutet, dass public Felder der abgeleiteten Klasse nicht vollständig initialisiert sind, wenn sie im Konstruktor der übergeordneten Klasse aufgerufen werden, und private Felder zu einem TypeError führen.

js
new (class C extends class B {
  constructor() {
    console.log(this.foo());
  }
} {
  #a = 1;
  foo() {
    return this.#a; // TypeError: Cannot read private member #a from an object whose class did not declare it
    // It's not really because the class didn't declare it,
    // but because the private field isn't initialized yet
    // when the superclass constructor is running
  }
})();

Die constructor-Methode kann einen Rückgabewert haben. Während die Basisklasse alles von ihrem Konstruktor zurückgeben kann, muss die abgeleitete Klasse ein Objekt oder undefined zurückgeben, andernfalls wird ein TypeError ausgelöst.

js
class ParentClass {
  constructor() {
    return 1;
  }
}

console.log(new ParentClass()); // ParentClass {}
// The return value is ignored because it's not an object
// This is consistent with function constructors

class ChildClass extends ParentClass {
  constructor() {
    return 1;
  }
}

console.log(new ChildClass()); // TypeError: Derived constructors may only return object or undefined

Wenn der Konstruktor der übergeordneten Klasse ein Objekt zurückgibt, wird dieses Objekt als this-Wert verwendet, auf dem die Klassenfelder der abgeleiteten Klasse definiert werden. Dieser Trick wird als "Return Overriding" bezeichnet, was es ermöglicht, dass Felder der abgeleiteten Klasse (einschließlich privater Felder) auf nicht verwandten Objekten definiert werden.

Der constructor folgt der normalen [Methoden]-Syntax(/de/docs/Web/JavaScript/Reference/Functions/Method_definitions), daher können Standardparameterwerte, Restparameter usw. verwendet werden.

js
class Person {
  constructor(name = "Anonymous") {
    this.name = name;
  }
  introduce() {
    console.log(`Hello, my name is ${this.name}`);
  }
}

const person = new Person();
person.introduce(); // Hello, my name is Anonymous

Der Konstruktor muss ein literaler Name sein. Berechnete Eigenschaften können keine Konstruktoren werden.

js
class Foo {
  // This is a computed property. It will not be picked up as a constructor.
  ["constructor"]() {
    console.log("called");
    this.a = 1;
  }
}

const foo = new Foo(); // No log
console.log(foo); // Foo {}
foo.constructor(); // Logs "called"
console.log(foo); // Foo { a: 1 }

Async-Methoden, Generator-Methoden, Zugriffsmethoden und Klassenfelder dürfen nicht constructor genannt werden. Private Namen dürfen nicht #constructor genannt werden. Jedes Mitglied namens constructor muss eine einfache Methode sein.

Beispiele

Verwendung des Konstruktors

Dieser Codeausschnitt stammt aus dem Beispiel für Klassen (Live-Demo).

js
class Square extends Polygon {
  constructor(length) {
    // Here, it calls the parent class' constructor with lengths
    // provided for the Polygon's width and height
    super(length, length);
    // NOTE: In derived classes, `super()` must be called before you
    // can use `this`. Leaving this out will cause a ReferenceError.
    this.name = "Square";
  }

  get area() {
    return this.height * this.width;
  }

  set area(value) {
    this.height = value ** 0.5;
    this.width = value ** 0.5;
  }
}

Aufruf von super in einem Konstruktor, der an ein anderes Prototyp gebunden ist

super() ruft den Konstruktor auf, der das Prototyp der aktuellen Klasse ist. Wenn Sie das Prototyp der aktuellen Klasse selbst ändern, ruft super() den Konstruktor auf, der das neue Prototyp ist. Das Ändern der prototype-Eigenschaft der aktuellen Klasse beeinflusst nicht, welchen Konstruktor super() aufruft.

js
class Polygon {
  constructor() {
    this.name = "Polygon";
  }
}

class Rectangle {
  constructor() {
    this.name = "Rectangle";
  }
}

class Square extends Polygon {
  constructor() {
    super();
  }
}

// Make Square extend Rectangle (which is a base class) instead of Polygon
Object.setPrototypeOf(Square, Rectangle);

const newInstance = new Square();

// newInstance is still an instance of Polygon, because we didn't
// change the prototype of Square.prototype, so the prototype chain
// of newInstance is still
//   newInstance --> Square.prototype --> Polygon.prototype
console.log(newInstance instanceof Polygon); // true
console.log(newInstance instanceof Rectangle); // false

// However, because super() calls Rectangle as constructor, the name property
// of newInstance is initialized with the logic in Rectangle
console.log(newInstance.name); // Rectangle

Help improve MDN

War diese Übersetzung hilfreich?

Ja Nein

Erfahren Sie, wie Sie beitragen können Diese Seite wurde automatisch aus dem Englischen übersetzt.

Übersetzung auf GitHub anzeigen • Fehler mit dieser Übersetzung melden

constructor

In diesem Artikel

Probieren Sie es aus

Syntax

Beschreibung

Beispiele

Verwendung des Konstruktors

Aufruf von super in einem Konstruktor, der an ein anderes Prototyp gebunden ist

Spezifikationen

Browser-Kompatibilität

Siehe auch

Help improve MDN