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

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

Fontes