Comment fonctionne async/await ?

Question

Accepted Answer

`async/await` est **du syntactic sugar sur les Promises** qui vous permet d'écrire du code asynchrone qui ressemble à du code synchrone. Une fonction `async` retourne toujours une Promise ; `await` met en pause la fonction jusqu'à ce qu'une Promise soit résolue, puis reprend avec sa valeur.

```js
async function loadUser(id) {
  try {
    const res = await fetch(`/api/users/${id}`); // pause until the response
    const user = await res.json();               // pause until parsed
    return user;                                  // becomes the resolved value
  } catch (err) {
    console.error(err); // catches rejections from any await above
  }
}
```

## Sequential vs parallel — a common performance mistake

`await` exécute les choses **l'une après l'autre**. Si deux requêtes ne dépendent pas l'une de l'autre, les attendre en séquence est lentement gaspilleur :

```js
// ❌ sequential — total time = a + b
const a = await getA();
const b = await getB();

// ✅ parallel — total time = max(a, b)
const [a, b] = await Promise.all([getA(), getB()]);
```

## Gestion des erreurs

Utilisez `try/catch` au lieu de `.catch`. Une Promise rejetée attendue lance une exception, donc un seul `catch` couvre tout le bloc.

## Sous le capot

C'est encore des Promises et la microtask queue — `await` ne bloque pas le fil d'exécution ; elle cède le contrôle pour que d'autre code s'exécute, puis reprend. N'oubliez pas : appeler une fonction `async` sans l'`await` (ou sans `.catch`) peut masquer les erreurs.

## Pourquoi c'est important

Cela rend les flux asynchrones lisibles et constitue le standard moderne pour séquencer le travail asynchrone — mais vous devez consciemment paralléliser les opérations indépendantes avec `Promise.all`.