Comment géres-tu les erreurs en JavaScript, y compris le code asynchrone ?

Question

Accepted Answer

Les erreurs synchrones utilisent **`try/catch/finally`**, et vous devez `throw` des objets `Error` (pas des chaînes) pour obtenir une stack trace.

```js
try {
  const data = JSON.parse(input);
} catch (err) {
  if (err instanceof SyntaxError) handleBadJson(err);
  else throw err;        // re-throw what you can't handle
} finally {
  cleanup();             // always runs
}
```

## Pourquoi c'est important

```js
// async/await → wrap awaits in try/catch
async function load() {
  try {
    return await fetch(url).then(r => r.json());
  } catch (err) { showError(err); }
}

// promises → use .catch
fetch(url).then(use).catch(showError);
```

## Un piège courant : try/catch n'attrape pas les callbacks asynchrones

```js
try {
  setTimeout(() => { throw new Error("boom"); }, 0); // ❌ NOT caught
} catch (e) { /* never runs — the throw happens later, outside this stack */ }
```

Le callback `setTimeout` s'exécute sur un tick ultérieur, donc le `try` environnant est long parti. Gérez l'erreur *à l'intérieur* du callback.

## Filets de sécurité globaux

```js
window.addEventListener("unhandledrejection", e => log(e.reason)); // browser
process.on("unhandledRejection", err => log(err));                 // Node
```

## Meilleures pratiques

- Lancez `Error` (ou des sous-classes personnalisées) pour les stack traces et les vérifications `instanceof`.
- Attrapez **spécifiquement** où vous pouvez vous rétablir ; laissez les erreurs inattendues se propager.
- Ne supprimez jamais les erreurs silencieusement (`catch (e) {}`). Enregistrez ou relancez toujours.