CKTIS / JavaScript
Construtor de classe e definição de métodos
Cria instâncias com `new`, inicializa o seu estado em `constructor` e distingue os métodos do protótipo dos métodos estáticos e `super()` de `super.method()`.
Versão: ECMAScript 2024 and the current web platform; runtime support varies
Sintaxe
class Base {
constructor(value) { this.value = value; }
method() { return this.value; }
static method() { return new Base(0); }
}
class Derived extends Base {
constructor(value) { super(value); }
method() { return super.method(); }
}new C(...) executa o construtor da classe C. Numa classe base, constructor(...) pode inicializar propriedades da instância, como this.value. Invocar C() sem new lança um TypeError. O construtor especial é um método comum não estático com o nome não calculado constructor. Defini-lo duas vezes provoca um SyntaxError, não uma sobrecarga. Usa parâmetros predefinidos para aceitar listas de argumentos diferentes num só construtor.
Se omitires o construtor, o JavaScript fornece um construtor predefinido: numa classe base não realiza operações adicionais e, numa classe derivada típica, encaminha os argumentos para o construtor da classe mãe. Num construtor derivado explícito, invoca super(...) antes de usares this; aceder a this demasiado cedo lança um ReferenceError. Um construtor derivado pode omitir super(...) se devolver explicitamente um objeto sem usar this.
No corpo da classe, escreve method(...) { ... } sem function nem vírgulas entre os métodos. Um método público de instância fica em C.prototype e é partilhado pelas instâncias; uma propriedade como this.value no exemplo pertence a uma só instância. static method(...) { ... } define um método na própria classe: invoca-o com C.method(). Métodos públicos comuns com o mesmo nome no mesmo objeto não são sobrecargas: a definição posterior substitui a anterior.
Em obj.method(), this é obj. Se extraíres o método e o invocares como fn(), this é undefined porque o corpo da classe é executado em modo estrito. Usa obj.method.bind(obj) para preservar o recetor. Num método de instância de uma classe derivada, super.method() inicia a procura no protótipo atual do objeto em que o método foi definido (por exemplo, Derived.prototype) e segue a cadeia de protótipos. No código apresentado, a procura começa em Base.prototype, mas se alterares o protótipo de Derived.prototype, o ponto de partida muda. super.method() invoca o método encontrado com o this atual; não invoca o construtor. É sintaxe de ECMAScript, não uma API do DOM. Confirma a compatibilidade no ambiente de execução de destino.
Exemplos
{
class Counter {
constructor(value = 0) {
this.value = value;
}
add(amount) {
this.value += amount;
return this.value;
}
}
class StepCounter extends Counter {
constructor(value, step) {
super(value);
this.step = step;
}
static defaultStep() {
return 2;
}
advance() {
return super.add(this.step);
}
}
const first = new StepCounter(10, StepCounter.defaultStep());
const second = new StepCounter(10, 5);
console.log(first.advance());
console.log(second.value);
console.log(first.advance === second.advance);
}Resultado
12 10 true
`super(value)` inicializa o valor do contador e `super.add(this.step)` aumenta para `12` o valor da primeira instância. A segunda mantém-se em `10` e `true` mostra que ambas partilham a mesma função `advance`.
Lições relacionadas
- JavaScript · Lição 7 · Avançado · Versão: 4
- JavaScript · Lição 17 · Avançado · Versão: 4
- JavaScript · Lição 39 · Intermédio · Versão: 3