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

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

Fontes