Cum gestionezi erorile în JavaScript, inclusiv codul asincron?

Question

Accepted Answer

Erorile sincrone folosesc **`try/catch/finally`**, și ar trebui să faci `throw` cu obiecte `Error` (nu cu stringuri) pentru a obține 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
}
```

## Gestionarea erorilor asincrone diferă după stil

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

## O capcană comună: try/catch nu prinde callback-urile asincrone

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

Callback-ul `setTimeout` se execută pe o tick ulterioară, deci `try`-ul înconjurător a dispărut. Gestionează eroarea *în interiorul* callback-ului.

## Rețele de siguranță globale

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

## Bune practici

- Fă `throw` cu `Error` (sau subclase personalizate) pentru stack traces și verificări `instanceof`.
- Prinde **în mod specific** unde poți recupera; lasă erorile neașteptate să se propagheze.
- Nu înghiți niciodată tăcut erorile (`catch (e) {}`). Întotdeauna loghează sau rearuncă.