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