Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / JavaScript

Costruttore di classe (`constructor`)

`constructor` imposta lo stato iniziale di un oggetto creato con `new`. In una classe derivata, la chiamata a `super()` rende disponibile `this`.

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

Sintassi

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

Il metodo constructor è un elemento speciale del corpo di una classe. In new ClassName(...) riceve gli argomenti passati e può impostare lo stato iniziale dell’oggetto, ad esempio con this.value = value. Chiamare ClassName(...) come una normale funzione, senza new, genera un TypeError.

Una classe può dichiarare al massimo un costruttore. Una seconda dichiarazione genera un SyntaxError, anche se la lista dei parametri è diversa. Invece dell’overloading, usa parametri con valori predefiniti o un parametro rest (...args). Il costruttore non può essere async, un generatore, un getter o un setter. Né static constructor() né ["constructor"]() definiscono il costruttore della classe. La proprietà ClassName.prototype.constructor punta normalmente alla classe stessa e non è un metodo di inizializzazione separato.

Se ometti il costruttore, JavaScript ne fornisce uno predefinito. In una classe base (senza extends), non esegue alcuna inizializzazione oltre a quella dei campi di istanza dichiarati. Se esiste un costruttore della superclasse, il costruttore predefinito della classe derivata gli inoltra tutti gli argomenti senza usare un iteratore di array, a differenza di una chiamata esplicita a super(...args). Una classe dichiarata con extends null è comunque una classe derivata, ma non c’è un costruttore della superclasse da invocare, quindi creare un’istanza con il costruttore predefinito genera un TypeError.

In un costruttore derivato esplicito, super(...) invoca il costruttore della superclasse e associa this all’oggetto restituito. Accedere a this prima di questa chiamata genera un ReferenceError. I campi di istanza della classe base vengono inizializzati prima dell’esecuzione del corpo del suo costruttore. Quelli della classe derivata vengono inizializzati al termine del costruttore della superclasse, prima che l’esecuzione prosegua oltre super(...).

Un oggetto restituito esplicitamente diventa il risultato di new. Un costruttore di base ignora i valori primitivi restituiti; un costruttore derivato genera un TypeError se restituisce un valore primitivo diverso da undefined. Un costruttore derivato può omettere super(...) e terminare correttamente solo restituendo esplicitamente un oggetto: raggiungere la fine del corpo o restituire undefined senza aver inizializzato this genera un ReferenceError.

Esempi

{
  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}`);
}

Risultato

#7: high
#8: normal

`super(id)` imposta `this.id` prima che l’inizializzatore del campo `label` lo legga. La seconda chiamata con `new` omette `priority`, quindi usa il valore predefinito `"normal"`. Esegui l’esempio in una console JavaScript che supporti i campi di classe pubblici.

Lezioni correlate

  • JavaScript · Lezione 13 · Intermedio · Versione: 3
  • JavaScript · Lezione 38 · Intermedio · Versione: 3

Fonti