constructor

Baseline Large disponibilit

Cette fonctionnalit est bien tablie et fonctionne sur de nombreux appareils et versions de navigateurs. Elle est disponible sur tous les navigateurs depuis mars 2016.

En savoir plus
Voir la compatibilit complte

La mthode constructor est une mthode qui est utilise pour crer 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 personnalise qui doit tre effectue avant que toute autre mthode puisse tre appele 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 dfaut sera fourni pour vous. Si votre classe est une classe de base, le constructeur par dfaut est vide :

constructor() {}

Si votre classe est une classe drive, le constructeur par dfaut 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 :-( (dtails : ${this.message})`;
  }
}

try {
  throw new ValidationError("Numro de tlphone 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 classe ValidationError n'a pas besoin d'un constructeur explicite, car elle n'a pas besoin de faire d'initialisation personnalise. Le constructeur par dfaut se charge alors d'initialiser le parent Error partir de l'argument qui lui est fourni.

Cependant, si vous fournissez votre propre constructeur, et que votre classe drive d'une certaine classe parente, alors vous devez appeler explicitement le constructeur de la classe parente en utilisant super. 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 :-( (dtails : ${this.message}, code : ${this.code})`;
  }
}

try {
  throw new ValidationError("Numro de tlphone 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 mthode spciale portant le nom constructor dans une classe. Avoir plus d'une occurrence d'une mthode constructor dans une classe lancera une erreur SyntaxError.

Exemples

Utilisation de la mthode du `constructor`

Cet extrait de code est tir de l'chantillon de classes (dmo 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 drives, `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 classe Square est modifi mais le constructeur de sa classe de base Polygon est toujours appel lorsqu'une nouvelle instance d'un carr est cre.

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); //false
console.log(Object.getPrototypeOf(Square.prototype) === Rectangle.prototype); //true

let newInstance = new Square();
console.log(newInstance.name); // Polygone

Spcifications

Spcification
ECMAScript 2027 LanguageSpecification # sec-static-semantics-constructormethod

Compatibilit des navigateurs

Voir aussi

Aider amliorer MDN

Cette page vous a-t-elle t utile ?

Oui Non

Apprendre contribuer

Cette page a t modifie le 17 fvr. 2025 par les contributeurices du MDN.

Voir cette page sur GitHub Signaler un problme avec ce contenu