constructor

BaselineWidely available

This feature is well established and works across many devices and browser versions. It’s been available across browsers since March 2016.

Dieconstructor-Methode ist eine spezielle Methode einerKlasse zur Erstellung und Initialisierung einer Objektinstanz dieser Klasse.

Hinweis:Diese Seite führt in dieconstructor-Syntax ein. Für dieconstructor-Eigenschaft, die in allen Objekten vorhanden ist, sieheObject.prototype.constructor.

Probieren Sie es aus

class Polygon {  constructor() {    this.name = "Polygon";  }}const poly1 = new Polygon();console.log(poly1.name);// Expected output: "Polygon"

Syntax

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

Es gibt einige zusätzliche Syntaxbeschränkungen:

Eine Klassenmethode namensconstructor kann keingetter,setter,async odergenerator sein.
Eine Klasse kann nicht mehr als eineconstructor-Methode haben.

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

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 Elternkonstruktor auf und gibt alle bereitgestellten Argumente weiter:

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

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

Das ermöglicht es, dass solcher Code funktioniert:

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;  }}

DieValidationError-Klasse benötigt keinen expliziten Konstruktor, da sie keine benutzerdefinierte Initialisierung benötigt.Der Standardkonstruktor kümmert sich dann um die Initialisierung des ElternfehlersError aus dem übergebenen Argument.

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

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 vonnew bei einer Klasse durchläuft die folgenden Schritte:

(Wenn es sich um eine abgeleitete Klasse handelt) Derconstructor-Körper vor demsuper()-Aufruf wird ausgewertet. Dieser Teil sollte nicht aufthis zugreifen, da es noch nicht initialisiert ist.
(Wenn es sich um eine abgeleitete Klasse handelt) Dersuper()-Aufruf wird ausgewertet, wodurch die übergeordnete Klasse durch denselben Prozess initialisiert wird.
DieFelder der aktuellen Klasse werden initialisiert.
Derconstructor-Körper nach demsuper()-Aufruf (oder der gesamte Körper, wenn es sich um eine Basisklasse handelt) wird ausgewertet.

Innerhalb desconstructor-Körpers können Sie auf das erstellte Objekt überthis zugreifen und die Klasse, die mitnew aufgerufen wurde, übernew.target ansprechen. Beachten Sie, dass Methoden (einschließlichGetter undSetter) und diePrototypenkette bereits aufthis initialisiert sind, bevor derconstructor ausgeführt wird, sodass Sie sogar auf Methoden der Unterklasse vom Konstruktor der Oberklasse aus zugreifen können. Wenn jedoch diese Methodenthis verwenden, istthis möglicherweise noch nicht vollständig initialisiert. Dies bedeutet, dass das Lesen von öffentlichen Feldern der abgeleiteten Klasseundefined ergibt, während das Lesen von privaten Feldern zu einemTypeError führt.

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  }})();

Dieconstructor-Methode kann einen Rückgabewert haben. Während die Basisklasse aus ihrem Konstruktor alles zurückgeben kann, muss die abgeleitete Klasse ein Objekt oderundefined zurückgeben, oder es wird einTypeError ausgelöst.

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 constructorsclass 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 alsthis-Wert verwendet, auf den dieKlassenfelder der abgeleiteten Klasse definiert werden. Dieser Trick wird"Rückgabeübersteuerung" genannt, der es ermöglicht, dass Felder der abgeleiteten Klasse (einschließlichprivater Felder) auf nicht verwandten Objekten definiert werden.

Derconstructor folgt der normalenMethoden-Syntax, sodassStandardparameterwerte,Restparameter usw. alle verwendet werden können.

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.

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 logconsole.log(foo); // Foo {}foo.constructor(); // Logs "called"console.log(foo); // Foo { a: 1 }

Asynchrone Methoden, Generatormethoden, Zugriffsmethoden und Klassenfelder dürfen nichtconstructor genannt werden. Private Namen dürfen nicht#constructor genannt werden. Jedes Mitglied, dasconstructor genannt wird, muss eine einfache Methode sein.

Beispiele

Verwendung des Konstruktors

Dieser Codeabschnitt stammt aus demKlassen-Beispiel (live Demo).

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;  }}

Super in einem anderen Prototyp gebundenen Konstruktor aufrufen

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

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 PolygonObject.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.prototypeconsole.log(newInstance instanceof Polygon); // trueconsole.log(newInstance instanceof Rectangle); // false// However, because super() calls Rectangle as constructor, the name property// of newInstance is initialized with the logic in Rectangleconsole.log(newInstance.name); // Rectangle