Qual è il vantaggio dello zucchero sintattico presentato sotto forma di async/await rispetto a Promise?

Il principale vantaggio di async/await rispetto alle promesse "puri" è la possibilità di scrivere codice asincrono in uno stile più sincrono e leggibile.

Confronto:

Aspetto	Promise	async/await
Leggibilità	Può portare a "catene di promesse".	Permette di scrivere codice quasi come sincrono.
Gestione degli errori	Usa .catch().	Usa il try...catch standard.
Sequenzialità	Richiede una concatenazione attenta o Promise.all.	Chiaro e facile da leggere.
Debugging	Può essere più difficile da seguire.	Simile al debug di codice sincrono.
Rumore sintattico	Molti .then(), .catch().	Meno boilerplate.

Esempio con promesse:

// Esempio con Promise
fetch('user.json')
  .then(response => response.json())
  .then(user => fetch(`https://api.github.com/users/${user.name}`))
  .then(githubUser => githubUser.json())
  .then(githubUser => {
    // Elaborazione dati
    console.log(githubUser);
  })
  .catch(error => {
    console.error('Errore:', error);
  });

Esempio con async/await:

// Esempio con async/await
async function getUserData() {
  try {
    const userResponse = await fetch('user.json');
    const user = await userResponse.json();

    const githubResponse = await fetch(`https://api.github.com/users/${user.name}`);
    const githubUser = await githubResponse.json();

    // Elaborazione dati
    console.log(githubUser);
  } catch (error) {
    console.error('Errore:', error);
  }
}

getUserData();

Quindi, async/await non sostituisce le promesse, ma è uno zucchero sintattico su di esse, rendendo le operazioni asincrone più intuitive e facili da mantenere.