¿Cómo se manejan los errores en JavaScript, incluyendo el código asíncrono?

Question

Accepted Answer

Los errores síncronos se manejan con **`try/catch/finally`**, y deberías lanzar (`throw`) objetos `Error` (no cadenas de texto) para obtener un 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
}
```

## El manejo de errores asíncronos varía según el estilo

```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);
```

## Una trampa común: try/catch no captura los callbacks asíncronos

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

El callback de `setTimeout` se ejecuta en un tick posterior, por lo que el `try` que lo rodea ya desapareció hace tiempo. Maneja el error *dentro* del callback.

## Redes de seguridad globales

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

## Buenas prácticas

- Lanza `Error` (o subclases personalizadas) para obtener stack traces y comprobaciones con `instanceof`.
- Captura **de forma específica** donde puedas recuperarte; deja que los errores inesperados se propaguen.
- Nunca silencies errores de forma callada (`catch (e) {}`). Siempre registra o relanza.