Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / JavaScript

Sintassi abbreviata per definire i metodi

La forma `name(p) { … }` definisce un metodo senza i due punti né `function`. La chiamata determina `this`, mentre la definizione determina da dove parte la ricerca con `super`.

Versione: ECMAScript 2024 and the current web platform; runtime support varies

Sintassi

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

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

In un letterale oggetto, name(p) { … } crea una proprietà propria chiamata name il cui valore è una funzione. Separa con virgole le proprietà del letterale, ma non inserire virgole tra i metodi di una classe. Un metodo pubblico di istanza è definito sul prototipo della classe; un metodo pubblico static è definito sulla classe stessa.

In obj.name(x), this è obj. La sintassi non associa this in modo permanente: se estrai il metodo, puoi comunque indicare esplicitamente this con call. Una funzione freccia scritta come name: (p) => … usa invece il this dell’ambito che la racchiude.

All’interno di un metodo, super.name avvia la ricerca dal prototipo corrente dell’oggetto su cui il metodo è stato definito. Copiare la funzione su un altro oggetto non cambia quell’oggetto di riferimento. In super.name(), il metodo trovato riceve il this corrente.

Anche name: function (p) { … } crea una proprietà il cui valore è una funzione, ma quella funzione non può usare super.name direttamente nel proprio corpo. Un metodo ordinario non è un costruttore: new obj.name() genera un TypeError. La definizione speciale constructor di una classe segue regole diverse. Non confondere questa sintassi con la forma abbreviata della proprietà { name }, che usa un’associazione già esistente per il nome name. ECMAScript 2024 specifica la sintassi; verifica il supporto negli ambienti di esecuzione meno recenti.

Esempi

{
  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));
}

Risultato

12
22

`Object.setPrototypeOf(item, base)` imposta `base` come prototipo di `item`. Nella prima chiamata `this.amount` vale `10`, quindi il risultato è `12`. Nella seconda, `call` fornisce un `this` con `amount: 20`, ma `super.total()` trova ancora il metodo su `base`. Il risultato è `22`.

Lezioni correlate

  • JavaScript · Lezione 12 · Intermedio · Versione: 3

Fonti