आप async Node कोड में त्रुटियों को कैसे संभालते हैं?

Question

Accepted Answer

त्रुटि हैंडलिंग async शैली के आधार पर अलग है, और इसे गलत तरीके से करने से मूक विफलता या क्रैश हो सकता है। मुख्य नियम: async/await के साथ `try/catch` का उपयोग करें, हमेशा Promise अस्वीकृति को संभालें, और कभी async कॉलबैक में त्रुटियों को असंभाली न होने दें।

## async/await — try/catch का उपयोग करें

```js
async function getUser(id) {
  try {
    const user = await db.findUser(id);   // a rejection here throws into catch
    return user;
  } catch (err) {
    logger.error(err);
    throw new AppError("Failed to load user", { cause: err }); // rethrow meaningfully
  }
}
```

## Promises — हमेशा .catch

```js
fetchData()
  .then(process)
  .catch(err => logger.error(err)); // an unhandled rejection can crash the process
```

यदि कोई Promise अस्वीकृति `.catch` के साथ नहीं है (या `await` के आसपास try/catch नहीं है) तो यह **unhandled rejection** बन जाता है — जो आधुनिक Node में प्रक्रिया को समाप्त करता है।

## क्लासिक जाल: async कॉलबैक में त्रुटियां try/catch से बच निकलती हैं

```js
// ❌ try/catch does NOT catch this — the throw happens on a LATER tick
try {
  setTimeout(() => { throw new Error("boom"); }, 100);
} catch (e) { /* never runs */ }
```

`try/catch` केवल **वर्तमान** सिंक्रोनस कॉल स्टैक में त्रुटियों को पकड़ता है। जब टाइमर/कॉलबैक चलता है, तब तक `try` ब्लॉक जा चुका है। कॉलबैक के *अंदर* त्रुटि को संभालें।

## Express async route हैंडलर्स को लपेटने की आवश्यकता है

```js
// ❌ a rejected async handler isn't caught by Express → request hangs
app.get("/users", async (req, res) => {
  const users = await db.getUsers(); // if this throws, Express doesn't catch it (pre-v5)
  res.json(users);
});

// ✅ wrap to forward errors to Express's error handler
const asyncH = (fn) => (req, res, next) => Promise.resolve(fn(req, res, next)).catch(next);
app.get("/users", asyncH(async (req, res) => {
  res.json(await db.getUsers()); // errors now go to next() → error middleware
}));
```

## ग्लोबल सेफ्टी नेट्स (अंतिम विकल्प, प्राथमिक हैंडलिंग नहीं)

```js
process.on("unhandledRejection", (reason) => { logger.error(reason); });
process.on("uncaughtException", (err) => { logger.error(err); process.exit(1); });
```

ये लॉग करने और (अनहैंडल्ड अपवादों के लिए) स्वच्छता से बंद करने के लिए सेफ्टी नेट्स हैं — जहां त्रुटियां होती हैं वहां हैंडलिंग के लिए विकल्प नहीं।

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

असंभाली async त्रुटियां क्रैश किए गए या मूकता से टूटी हुई Node सेवाओं का शीर्ष कारण हैं।

नियमों में महारत हासिल करना — `await` के आसपास `try/catch`, हमेशा `.catch` Promises, async कॉलबैक के *अंदर* त्रुटियों को संभालें (try/catch उन तक नहीं पहुंच सकता), और Express async हैंडलर्स को लपेटें त्रुटियों को आगे बढ़ाने के लिए — लंबित अनुरोधों, मूक विफलताओं, और प्रक्रिया क्रैश को रोकता है।

ग्लोबल हैंडलर्स एक अंतिम सेफ्टी नेट प्रदान करते हैं, लेकिन सही प्रति-ऑपरेशन हैंडलिंग वह है जो async Node कोड को मजबूत और डीबग करने योग्य बनाता है।