Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / JavaScript

Construtor de classe (`constructor`)

`constructor` define o estado inicial de um objeto criado com `new`. Numa classe derivada, a chamada a `super()` permite aceder a `this`.

Versão: ECMAScript 2024 and the current web platform; runtime support varies

Sintaxe

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

O método constructor é um elemento especial do corpo de uma classe. Em new ClassName(...), recebe os argumentos fornecidos e pode definir o estado inicial do objeto, por exemplo, com this.value = value. Chamar ClassName(...) como uma função normal, sem new, lança um TypeError.

Uma classe pode declarar, no máximo, um construtor. Uma segunda declaração provoca um SyntaxError, mesmo que tenha uma lista de parâmetros diferente. Em vez de sobrecarga, usa valores predefinidos nos parâmetros ou um parâmetro rest (...args). O construtor não pode ser async, um gerador, um getter ou um setter. Nem static constructor() nem ["constructor"]() define o construtor da classe. A propriedade ClassName.prototype.constructor aponta normalmente para a própria classe; não é um método de inicialização separado.

Se omitires o construtor, o JavaScript fornece um construtor predefinido. Numa classe base (sem extends), não faz nenhuma inicialização adicional para além da dos campos de instância declarados. Se existir um construtor da superclasse, o construtor predefinido da classe derivada passa-lhe todos os argumentos sem usar um iterador de array, ao contrário de uma chamada explícita a super(...args). Uma classe declarada com extends null continua a ser derivada, mas não há um construtor da superclasse que possa ser invocado, pelo que criar uma instância com o construtor predefinido lança um TypeError.

Num construtor derivado explícito, super(...) invoca o construtor da superclasse e associa this ao objeto devolvido. Aceder a this antes dessa chamada lança um ReferenceError. Os campos de instância da classe base são inicializados antes da execução do corpo do seu construtor. Os da classe derivada são inicializados depois de o construtor da superclasse terminar e antes de a execução prosseguir após super(...).

Um objeto devolvido explicitamente passa a ser o resultado de new. Um construtor de base ignora os valores primitivos devolvidos; um construtor derivado lança um TypeError se devolver um valor primitivo diferente de undefined. Um construtor derivado só pode omitir super(...) e terminar com sucesso se devolver explicitamente um objeto: chegar ao fim do corpo ou devolver undefined sem ter inicializado this lança um ReferenceError.

Exemplos

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

Resultado

#7: high
#8: normal

`super(id)` define `this.id` antes de o inicializador do campo `label` ler esse valor. A segunda chamada com `new` omite `priority`, pelo que é usado o valor predefinido `"normal"`. Executa o exemplo numa consola JavaScript que suporte campos de classe públicos.

Lições relacionadas

  • JavaScript · Lição 13 · Intermédio · Versão: 3
  • JavaScript · Lição 38 · Intermédio · Versão: 3

Fontes