CKTIS / JavaScript
Function.prototype e atribuição de métodos ao protótipo
Distingue o protótipo da própria função do protótipo das suas instâncias e partilha o mesmo método entre essas instâncias.
Versão: ECMAScript 2024 and the current web platform; runtime support varies
Sintaxe
Function.prototype
Object.getPrototypeOf(Constructor)
Constructor.prototype.method = function (arg) { /* method body */ };
const instance = new Constructor();
instance.method(arg);
Object.getPrototypeOf(instance)Function.prototype é o objeto incorporado do qual uma função normal como Counter herda os métodos call, apply e bind. Usa Object.getPrototypeOf(Counter) para consultar o protótipo da própria função. Já Counter.prototype é uma propriedade própria do construtor: refere-se ao objeto que new Counter(...) usa como protótipo da nova instância.
Counter.prototype.double = function () { return this.value * 2; }; guarda a função no protótipo, em vez de a copiar para cada instância. Em early.double(), o JavaScript procura primeiro uma propriedade própria double em early e depois percorre a cadeia de protótipos. Mesmo que encontre a função no protótipo, this é early. Uma função de seta não serve de substituto neste caso: obtém this do âmbito envolvente.
Adicionar um método ao objeto protótipo existente também o disponibiliza às instâncias já criadas, a menos que uma propriedade própria o oculte. Em contrapartida, Counter.prototype = {} substitui o objeto utilizado pelas chamadas seguintes a new Counter(...). As instâncias existentes continuam a referenciar o protótipo anterior.
Adiciona os métodos de instância ao protótipo do teu construtor, não a Function.prototype. Alterar esse protótipo incorporado pode também afetar outras funções que herdam dele.
Exemplos
{
function Counter(value) {
this.value = value;
}
const early = new Counter(3);
Counter.prototype.double = function () {
return this.value * 2;
};
const late = new Counter(5);
console.log(Object.getPrototypeOf(Counter) === Function.prototype);
console.log(Object.getPrototypeOf(early) === Counter.prototype);
console.log(early.double === late.double);
console.log(late.double());
Counter.prototype = {};
console.log(early.double());
console.log(typeof (new Counter(7)).double);
}Resultado
true true true 10 6 undefined
`early` é criada antes de o método ser adicionado, mas herda-o na mesma. Depois de substituir o protótipo, `early.double()` continua a devolver `6`, enquanto `typeof` devolve `"undefined"` para `double` na nova instância.
Lições relacionadas
- JavaScript · Lição 38 · Intermédio · Versão: 3