CKTIS / JavaScript
Sintassi di definizione dei metodi nei letterali oggetto
Con `method(param) { ... }` definisci un metodo senza `:` né `function`. La chiamata determina `this`, mentre il punto di definizione stabilisce da dove cerca `super`.
Versione: ECMAScript 2024 and the current web platform; runtime support varies
Sintassi
const obj = {
method(param) {},
[keyExpression](param) {},
*generator() {},
async fetchValue() {},
async *streamValues() {},
get value() { return this._value; },
set value(next) { this._value = next; },
};In un letterale oggetto, method(param) { ... } crea una proprietà dati propria il cui valore è una funzione. La proprietà è scrivibile, enumerabile e configurabile. Usa [keyExpression] al posto del nome per calcolare la chiave quando viene creato l’oggetto. La chiave risultante è una stringa o un simbolo.
La chiamata a un metodo generatore (*method() { ... }) restituisce un iteratore generatore. Un metodo asincrono (async method() { ... }) restituisce una Promise, mentre un metodo generatore asincrono (async *method() { ... }) restituisce un iteratore asincrono. Tutte queste forme accettano chiavi calcolate. get value() { ... } e set value(next) { ... } definiscono invece funzioni di accesso eseguite rispettivamente in lettura e in assegnazione, senza chiamare value().
In obj.method(), this è obj. Leggere la funzione non la lega all’oggetto: se estrai il metodo e lo chiami come funzione autonoma, non riceve l’oggetto ricevente originale. Usa fn.call(obj) per fornirlo esplicitamente. Una funzione freccia memorizzata in una proprietà prende invece this dall’ambito circostante.
super.prop e super[key] avviano la ricerca dal prototipo corrente dell’oggetto in cui è stato definito il metodo ([[HomeObject]]). Copiare la funzione in un altro oggetto non cambia il punto di partenza, anche se può cambiare this. super.method() passa il this corrente alla funzione trovata. La chiamata al costruttore super() non è consentita in un metodo di un letterale oggetto.
method() { ... } non equivale del tutto a method: function () { ... }. new obj.method() genera un TypeError se il metodo è definito con la sintassi concisa; un’espressione function ordinaria, sincrona e non generatrice può invece fungere da costruttore. Scrivere super.prop direttamente nel corpo di tale espressione function provoca un SyntaxError.
Esempi
{
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);
}Risultato
base:A base:B TypeError ordinary
Nel letterale, `__proto__: base` imposta il prototipo di `original`. Entrambe le chiamate trovano `base.label` tramite `super`, ma `this.name` vale prima `A` e poi `B`. `new` genera un `TypeError` con `describe`; la funzione ordinaria `regular` costruisce un oggetto con `value` uguale a `ordinary`.
Lezioni correlate
- JavaScript · Lezione 20 · Avanzato · Versione: 4