CKTIS / JavaScript
Function.prototype e a sintaxe do construtor de classe
Distingue a cadeia de protótipos de uma função da propriedade `.prototype` usada para as instâncias e vê como `new`, `constructor` e `super()` se relacionam com a herança.
Versão: ECMAScript 2024 and the current web platform; runtime support varies
Sintaxe
function C(value) {
this.value = value;
}
C.prototype.read = function () {
return this.value;
};
const instance = new C(1);
Function.prototype
Object.getPrototypeOf(C)
C.prototype
Object.getPrototypeOf(instance)
class Base {
constructor(value) {
this.value = value;
}
read() {
return this.value;
}
}
class Derived extends Base {
constructor(value) {
super(value);
this.ready = true;
}
}
const derived = new Derived(2);Function.prototype é o objeto função incorporado do qual as funções herdam métodos como call, apply e bind. É o protótipo direto de uma função comum declarada com function e de uma classe sem extends. A chamada Function.prototype() devolve undefined, mas new Function.prototype() lança um TypeError.
C.prototype é diferente: é uma propriedade própria de uma função construtora comum ou de uma classe C. Se o seu valor for um objeto, new C(...) usa-o normalmente como protótipo da instância. Podes verificar essa ligação com Object.getPrototypeOf(instance). Um construtor pode, em vez disso, devolver explicitamente outro objeto. Adicionar .prototype a uma função seta não permite usá-la com new.
Numa class, constructor(...) { ... } inicializa a instância, normalmente através de atribuições a this. Os métodos públicos de instância, como read(), ficam em C.prototype; os métodos static ficam em C. Ao contrário do que acontece com uma função comum, chamar diretamente uma classe com C(...) lança um TypeError. Substituir .prototype numa função comum não altera o protótipo das instâncias existentes. Numa classe, a propriedade não permite escrita, mas o próprio objeto protótipo continua a poder ser alterado.
Em class Derived extends Base, Derived herda de Base e Derived.prototype herda de Base.prototype. Num construtor derivado explícito, chama super(...) antes de usar this; usá-lo antes disso lança um ReferenceError. Podes omitir super() se devolveres diretamente um objeto sem usar this. Se omitires por completo o construtor derivado, o construtor predefinido encaminha os argumentos.
Exemplos
{
function Legacy(name) {
this.name = name;
}
Legacy.prototype.read = function () {
return this.name;
};
class Modern {
constructor(name) {
this.name = name;
}
read() {
return this.name;
}
}
const a = new Legacy('Ada');
const b = new Modern('Lin');
const prototypeOf = Object.getPrototypeOf;
const descriptor = Object.getOwnPropertyDescriptor;
console.log(`${prototypeOf(Legacy) === Function.prototype} ${prototypeOf(Modern) === Function.prototype}`);
console.log(`${prototypeOf(a) === Legacy.prototype} ${prototypeOf(b) === Modern.prototype}`);
console.log(`${a.read()} ${b.read()}`);
console.log(`${descriptor(Legacy, 'prototype').writable} ${descriptor(Modern, 'prototype').writable}`);
try {
Modern('Lin');
} catch (error) {
console.log(error.name);
}
}Resultado
true true true true Ada Lin true false TypeError
Executa o bloco completo numa consola que suporte a sintaxe `class`. As duas primeiras linhas comparam os protótipos dos construtores e das instâncias; a última mostra o nome do erro sem depender da sua mensagem.
Lições relacionadas
- JavaScript · Lição 32 · Avançado · Versão: 4