Hinweis:Diese Seite stellt dieconstructor-Syntax vor. Informationen zurconstructor-Eigenschaft, die in allen Objekten vorhanden ist, finden Sie unterObject.prototype.constructor.

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

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

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

constructor() {}

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

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

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

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

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

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

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

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 }

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

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

Help improve MDN