आप JavaScript में त्रुटियों को कैसे संभालते हैं, जिसमें async कोड भी शामिल है?

Question

Accepted Answer

सिंक्रोनस त्रुटियाँ **`try/catch/finally`** का उपयोग करती हैं, और आपको `throw` `Error` ऑब्जेक्ट्स (स्ट्रिंग नहीं) करना चाहिए ताकि आपको 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
}
```

## यह क्यों महत्वपूर्ण है

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

## Async त्रुटि हैंडलिंग शैली के आधार पर भिन्न होती है

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

`setTimeout` कॉलबैक बाद में चलता है, इसलिए आसपास का `try` बहुत पहले चला गया है। त्रुटि को *कॉलबैक के अंदर* संभालें।

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

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

## सर्वोत्तम प्रथाएँ

- Stack traces और `instanceof` जांच के लिए `Error` (या कस्टम सबक्लास) throw करें।
- **विशेष रूप से** जहाँ आप पुनः प्राप्त कर सकते हैं, वहाँ पकड़ें; अप्रत्याशित त्रुटियों को बुलबुले करने दें।
- कभी भी त्रुटियों को चुप्पी से निगल न लें (`catch (e) {}`). हमेशा लॉग करें या फिर से throw करें।