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

CKTIS / JavaScript

Sintaxe de definição de métodos em literais de objeto

A forma `method(param) { ... }` define um método sem `:` nem `function`. A chamada determina `this`, mas o local da definição determina onde começa a pesquisa de `super`.

Versão: ECMAScript 2024 and the current web platform; runtime support varies

Sintaxe

const obj = {
  method(param) {},
  [keyExpression](param) {},
  *generator() {},
  async fetchValue() {},
  async *streamValues() {},
  get value() { return this._value; },
  set value(next) { this._value = next; },
};

Num literal de objeto, method(param) { ... } cria uma propriedade de dados própria cujo valor é uma função. A propriedade permite escrita, é enumerável e é configurável. Usa [keyExpression] em vez do nome para calcular a chave no momento em que o objeto é criado. A chave resultante é uma cadeia de carateres ou um símbolo.

A chamada de um método gerador (*method() { ... }) devolve um iterador gerador. Um método assíncrono (async method() { ... }) devolve uma promessa (Promise) e um método gerador assíncrono (async *method() { ... }) devolve um iterador assíncrono. Todas estas formas aceitam chaves calculadas. Já get value() { ... } e set value(next) { ... } definem acessores executados, respetivamente, na leitura e na atribuição da propriedade, sem chamar value().

Em obj.method(), this é obj. Ler a função não a associa ao objeto: se extraíres o método e o chamares como função independente, este não recebe o recetor original. Usa fn.call(obj) para o fornecer explicitamente. Uma função seta guardada numa propriedade obtém this do âmbito envolvente.

super.prop e super[key] iniciam a pesquisa no protótipo atual do objeto em que o método foi definido ([[HomeObject]]). Copiar a função para outro objeto não altera esse ponto de partida, embora possa alterar this. super.method() passa o this atual à função encontrada. A chamada ao construtor super() não é permitida num método de um literal de objeto.

method() { ... } não é totalmente equivalente a method: function () { ... }. Usar new obj.method() com um método definido pela sintaxe concisa lança um TypeError, ao passo que uma expressão function normal, síncrona e não geradora pode ser usada como construtor. Escrever super.prop diretamente no corpo dessa expressão function provoca um SyntaxError.

Exemplos

{
  const key = 'describe';
  const base = {
    label() { return `base:${this.name}`; },
  };
  const original = {
    __proto__: base,
    name: 'A',
    [key]() { return super.label(); },
    regular: function () { this.value = 'ordinary'; },
  };
  const other = { name: 'B', describe: original.describe };

  console.log(original.describe());
  console.log(other.describe());
  try {
    new original.describe();
  } catch (error) {
    console.log(error.name);
  }
  console.log(new original.regular().value);
}

Resultado

base:A
base:B
TypeError
ordinary

No literal, `__proto__: base` define o protótipo de `original`. Ambas as chamadas encontram `base.label` através de `super`, mas `this.name` vale primeiro `A` e depois `B`. `new` lança um `TypeError` com `describe`; a função normal `regular` constrói um objeto cujo `value` é `ordinary`.

Lições relacionadas

  • JavaScript · Lição 20 · Avançado · Versão: 4

Fontes