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

CKTIS / JavaScript

Sintaxe abreviada para definir métodos

A forma `name(p) { … }` define um método sem dois-pontos nem `function`. A chamada determina `this`, enquanto a definição determina onde começa a pesquisa com `super`.

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

Sintaxe

const obj = {
  method(p) { /* body */ },
};

class Example {
  method(p) { /* body */ }
  static method(p) { /* body */ }
}

Num literal de objeto, name(p) { … } cria uma propriedade própria chamada name, cujo valor é uma função. As propriedades do literal separam-se por vírgulas, mas não se colocam vírgulas entre os métodos de uma classe. Um método público de instância é definido no protótipo da classe; um método público static é definido na própria classe.

Em obj.name(x), this é obj. A sintaxe não fixa this: se extraíres o método, podes continuar a fornecer this explicitamente com call. Já uma função de seta escrita como name: (p) => … usa o this do âmbito envolvente.

Dentro de um método, super.name começa a pesquisa no protótipo atual do objeto em que o método foi definido. Copiar a função para outro objeto não altera esse objeto de referência. Em super.name(), o método encontrado recebe o this atual.

A forma name: function (p) { … } também cria uma propriedade cujo valor é uma função, mas essa função não pode usar super.name diretamente no seu corpo. Um método comum não é um construtor: new obj.name() lança um TypeError. A definição especial constructor de uma classe segue outras regras. Não confundas esta sintaxe com a forma abreviada de propriedade { name }, que usa uma ligação existente com o nome name. O ECMAScript 2024 especifica esta sintaxe; verifica o suporte em ambientes de execução mais antigos.

Exemplos

{
  const base = {
    total() { return this.amount; },
  };
  const item = {
    amount: 10,
    total(extra) { return super.total() + extra; },
  };
  Object.setPrototypeOf(item, base);

  console.log(item.total(2));
  console.log(item.total.call({ amount: 20 }, 2));
}

Resultado

12
22

`Object.setPrototypeOf(item, base)` define `base` como protótipo de `item`. Na primeira chamada, `this.amount` vale `10`, pelo que o resultado é `12`. Na segunda, `call` fornece um `this` com `amount: 20`, mas `super.total()` continua a encontrar o método em `base`. O resultado é `22`.

Lições relacionadas

  • JavaScript · Lição 12 · Intermédio · Versão: 3

Fontes