Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / JavaScript

Constructeur de classe (`constructor`)

`constructor` définit l’état initial d’un objet créé avec `new`. Dans une classe dérivée, l’appel à `super()` rend `this` accessible.

Version : ECMAScript 2024 and the current web platform; runtime support varies

Syntaxe

class Base {
  constructor(value) {
    this.value = value;
  }
}

class Derived extends Base {
  constructor(value, extra = 0) {
    super(value);
    this.extra = extra;
  }
}

new Base(1);
new Derived(1, 2);

La méthode constructor est un élément spécial du corps d’une classe. Dans new ClassName(...), elle reçoit les arguments fournis et peut définir l’état initial de l’objet, par exemple avec this.value = value. Appeler ClassName(...) comme une fonction ordinaire, sans new, déclenche une TypeError.

Une classe ne peut déclarer qu’un seul constructeur. Une seconde déclaration déclenche une SyntaxError, même si la liste des paramètres diffère. Utilisez des paramètres par défaut ou un paramètre du reste (...args) plutôt que la surcharge. Le constructeur ne peut être ni async, ni une méthode génératrice, ni un accesseur en lecture ou en écriture. Ni static constructor() ni ["constructor"]() ne définit le constructeur de la classe. La propriété ClassName.prototype.constructor désigne normalement la classe elle-même ; ce n’est pas une méthode d’initialisation distincte.

En l’absence de constructeur explicite, JavaScript fournit un constructeur par défaut. Dans une classe de base (sans extends), il n’effectue aucune initialisation supplémentaire au-delà des champs d’instance déclarés. Dans une classe dérivée, s’il existe un constructeur parent, le constructeur par défaut lui transmet tous les arguments sans passer par un itérateur de tableau, contrairement à un appel explicite à super(...args). Une classe déclarée avec extends null reste une classe dérivée, mais il n’y a pas de constructeur parent à appeler : créer une instance avec le constructeur par défaut déclenche donc une TypeError.

Dans un constructeur dérivé explicite, super(...) appelle le constructeur parent et lie this à l’objet renvoyé. Accéder à this avant cet appel déclenche une ReferenceError. Les champs d’instance de la classe de base sont initialisés avant l’exécution du corps de son constructeur. Ceux de la classe dérivée le sont après le retour du constructeur parent, avant que l’exécution reprenne après super(...).

Un objet renvoyé explicitement devient le résultat de new. Un constructeur de base ignore les valeurs primitives renvoyées ; un constructeur dérivé déclenche une TypeError pour toute valeur primitive renvoyée autre que undefined. Un constructeur dérivé ne peut omettre super(...) et réussir qu’en renvoyant explicitement un objet : atteindre la fin du corps ou renvoyer undefined sans que this ait été initialisé déclenche une ReferenceError.

Exemples

{
  class Ticket {
    constructor(id) {
      this.id = id;
    }
  }

  class PriorityTicket extends Ticket {
    label = `#${this.id}`;

    constructor(id, priority = "normal") {
      super(id);
      this.priority = priority;
    }
  }

  const first = new PriorityTicket(7, "high");
  const second = new PriorityTicket(8);
  console.log(`${first.label}: ${first.priority}`);
  console.log(`${second.label}: ${second.priority}`);
}

Résultat

#7: high
#8: normal

`super(id)` définit `this.id` avant que l’initialiseur du champ `label` ne le lise. Le second appel avec `new` omet `priority`, qui prend donc la valeur par défaut `"normal"`. Exécutez l’exemple dans une console JavaScript qui prend en charge les champs de classe publics.

Leçons associées

  • JavaScript · Leçon 13 · Intermédiaire · Version : 3
  • JavaScript · Leçon 38 · Intermédiaire · Version : 3

Sources