CKTIS / JavaScript
Sintassi abbreviata dei metodi nei letterali oggetto
La forma `method() {}` definisce un metodo direttamente in un letterale oggetto. La chiamata determina `this`, ma `super` inizia la ricerca dal prototipo dell’oggetto in cui è stato definito il metodo.
Versione: ECMAScript 2024 and the current web platform; runtime support varies
Sintassi
const key = "computed";
({ method(a, b) { /* body */ } });
({ [key](a) { /* body */ } });
({ *generate() { /* body */ }, async run() { /* body */ }, async *stream() { /* body */ } });In un letterale oggetto, method(a) { … } definisce un metodo senza i due punti né la parola chiave function. Crea una proprietà dati propria dell’oggetto, scrivibile, enumerabile e configurabile. { method } è un’altra abbreviazione: usa un binding esistente come valore della proprietà e non definisce una nuova funzione.
In obj.method(), this vale obj. Estrarre il metodo non lo lega all’oggetto; se lo passi come callback e vuoi mantenere il ricevitore, usa obj.method.bind(obj). Una funzione freccia usata come valore di una proprietà prende invece this dal contesto lessicale circostante.
super.method() inizia la ricerca dal prototipo attuale dell’oggetto in cui è stato definito il metodo e passa lo stesso this al metodo chiamato. Copiare il metodo in un altro oggetto non cambia il punto di partenza. Con method: function () { … } non puoi usare super direttamente nel corpo della funzione. Un’espressione di funzione ordinaria può fungere da costruttore, ma new obj.method() genera un TypeError se il metodo è definito in forma abbreviata.
[key](a) { … } usa una chiave calcolata. *generate(), async run() e async *stream() definiscono rispettivamente un metodo generatore, uno asincrono e uno generatore asincrono, ognuno con il proprio corpo. Queste forme sono specificate in ECMAScript 2024; verifica che siano supportate nell’ambiente di esecuzione di destinazione.
Esempi
(() => {
const base = { read() { return this.value; } };
const obj = {
value: 2,
read() { return super.read() + 1; },
ordinary: function () {},
};
Object.setPrototypeOf(obj, base);
const other = { value: 9, read: obj.read };
console.log(obj.read());
console.log(other.read());
console.log(new obj.ordinary() instanceof obj.ordinary);
try {
new obj.read();
} catch (error) {
console.log(error.name);
}
})();Risultato
3 10 true TypeError
Entrambe le chiamate trovano `base.read` tramite `super`. La prima usa `obj` come `this` e produce `3`; la seconda usa `other` e produce `10`. `true` conferma che `ordinary` ha creato un’istanza, mentre `TypeError` mostra che il metodo abbreviato `read` non è un costruttore.
Lezioni correlate
- JavaScript · Lezione 41 · Avanzato · Versione: 4