तुम JavaScript मध्ये त्रुटी कसे हाताळता, async कोड सह?

Question

Accepted Answer

समकालीन त्रुटी **`try/catch/finally`** वापरतात, आणि तुम्ही `Error` ऑब्जेक्ट `throw` केले पाहिजे (स्ट्रिंग नाही) म्हणून तुम्हाला 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
}
```

## Async त्रुटी हाताळणे शैलीनुसार वेगळे आहे

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

## सामान्य सापळा: try/catch async callbacks पकडत नाही

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

`setTimeout` callback नंतर tick वर चालते, तर सभोवतालचा `try` खूप आधीच गेला आहे. त्रुटीला *callback च्या अंदर* हाताळा.

## वैश्विक सुरक्षा जाळे

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

## सर्वोत्तम सराव

- Stack traces आणि `instanceof` checks साठी `Error` (किंवा कस्टम subclasses) `throw` करा.
- **विशेषतः** जिथे तुम्ही पुनर्प्राप्त करू शकता तिथे पकडा; अप्रत्याशित त्रुटी बुडबुडा करू द्या.
- कधीही चुप करून त्रुटी गळा करू नका (`catch (e) {}`). नेहमी log किंवा rethrow करा.