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.

La méthodeconstructor est une méthode qui est utilisée pour créer et initialiser un objet lorsqu'on utilise le mot cléclass.

Exemple interactif

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

Syntaxe

constructor() { ... }constructor(argument0) { ... }constructor(argument0, argument1) { ... }constructor(argument0, argument1, ... , argumentN) { ... }

Description

Un constructeur vous permet de fournir toute initialisation personnalisée qui doit être effectuée avant que toute autre méthode puisse être appelée sur un objet instancié.

class Person {  constructor(name) {    this.name = name;  }  introduce() {    console.log(`Hello, my name is ${this.name}`);  }}const otto = new Person("Otto");otto.introduce();

Si vous ne fournissez pas votre propre constructeur, alors un constructeur par défaut sera fourni pour vous. Si votre classe est une classe de base, le constructeur par défaut est vide :

constructor() {}

Si votre classe est une classe dérivée, le constructeur par défaut appelle le constructeur parent, en transmettant tous les arguments qui ont été fournis :

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

Cela permet à un code comme celui-ci de fonctionner :

class ValidationError extends Error {  printCustomerMessage() {    return `La validation a échoué :-( (détails : ${this.message})`;  }}try {  throw new ValidationError("Numéro de téléphone invalide");} catch (error) {  if (error instanceof ValidationError) {    console.log(error.name); // Il s'agit d'une erreur au lieu de ValidationError !    console.log(error.printCustomerMessage());  } else {    console.log("Erreur inconnue", error);    throw error;  }}

La classeValidationError n'a pas besoin d'un constructeur explicite, car elle n'a pas besoin de faire d'initialisation personnalisée. Le constructeur par défaut se charge alors d'initialiser le parentError à partir de l'argument qui lui est fourni.

Cependant, si vous fournissez votre propre constructeur, et que votre classe dérive d'une certaine classe parente, alors vous devez appeler explicitement le constructeur de la classe parente en utilisantsuper. Par exemple :

class ValidationError extends Error {  constructor(message) {    super(message); // appelle le constructeur de la classe parent    this.name = "ValidationError";    this.code = "42";  }  printCustomerMessage() {    return `La validation a échoué :-( (détails : ${this.message}, code : ${this.code})`;  }}try {  throw new ValidationError("Numéro de téléphone invalide");} catch (error) {  if (error instanceof ValidationError) {    console.log(error.name); // Maintenant, c'est une ValidationError !    console.log(error.printCustomerMessage());  } else {    console.log("Unknown error", error);    throw error;  }}

Il ne peut y avoir qu'une seule méthode spéciale portant le nom «constructor » dans une classe. Avoir plus d'une occurrence d'une méthodeconstructor dans une classe lancera une erreurSyntaxError.

Exemples

Utilisation de la méthode du`constructor`

Cet extrait de code est tiré de l'échantillon de classes (démo en direct).

class Square extends Polygon {  constructor(length) {    // Ici, on appelle le constructeur de la classe parente avec des longueurs    // fournies pour la largeur et la hauteur du polygone.    super(length, length);    // NOTE : Dans les classes dérivées, `super()` doit être appelé avant de pouvoir    // utiliser `this`. Si vous ne le faites pas, cela provoquera une ReferenceError.    this.name = "Carré";  }  get area() {    return this.height * this.width;  }  set area(value) {    this.height = value ** 0.5;    this.width = value ** 0.5;  }}

Un autre exemple

Ici, le prototype de la classeSquare est modifié — mais le constructeur de sa classe de basePolygon est toujours appelé lorsqu'une nouvelle instance d'un carré est créée.

class Polygon {  constructor() {    this.name = "Polygone";  }}class Square extends Polygon {  constructor() {    super();  }}class Rectangle {}Object.setPrototypeOf(Square.prototype, Rectangle.prototype);console.log(Object.getPrototypeOf(Square.prototype) === Polygon.prototype); //falseconsole.log(Object.getPrototypeOf(Square.prototype) === Rectangle.prototype); //truelet newInstance = new Square();console.log(newInstance.name); // Polygone