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

Question

Accepted Answer

त्रुटी हाताळणे async शैलीनुसार भिन्न असते, आणि जर हे चुकीचे केल्यास मूक अपयशात्मकता किंवा क्रॅश होतात. मुख्य नियम: async/await सह `try/catch` वापरा, नेहमी Promise rejections हाताळा, आणि async callbacks मध्ये त्रुटी कधीही हाताळल्याशिवाय सोडू नका.

## 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 rejection ज्यास `.catch` नाहीत (किंवा `await` च्या सभोवतालची try/catch नाहीत) **unhandled rejection** बनते — जी आधुनिक Node मध्ये प्रक्रिया संपवते.

## क्लासिक जाळ: async callbacks मध्ये त्रुटी 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` केवळ **सध्याच्या** सिंक्रोनस call stack मध्ये त्रुटींचा हाताळ करतो. जेव्हा timer/callback चालू होतो, तेव्हा `try` ब्लॉक दूर गेलेला असतो. त्रुटी *callback च्या अंदर* हाताळा.

## Express async route handlers ला लपेटणे आवश्यक आहे

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

हे log करण्यासाठी आणि (अहंकारी अपवादांसाठी) स्वच्छपणे बाहेर पडण्यासाठी सुरक्षा जाळ्या आहेत — जेथे त्रुटींचा हाताळ होतो तेथे त्याचा पर्यायी नाही.

## हे का महत्त्वाचे आहे

अहंकारी async त्रुटी हे Node services च्या क्रॅश किंवा मूकपणे तुटलेल्या कारणांपैकी एक शीर्ष कारण आहे.

नियमांमा mastering — `await` च्या सभोवतालची `try/catch`, नेहमी `.catch` Promises, async callbacks च्या *अंदर* त्रुटी हाताळा (try/catch त्यांना पोहोचू शकत नाही), आणि त्रुटींना पुढे पाठवण्यासाठी Express async handlers ला लपेटा — लटकलेल्या विनंत्या, मूक अपयशात्मकता, आणि प्रक्रिया क्रॅश टाळतो.

वैश्विक handlers अंतिम सुरक्षा जाळी प्रदान करतात, परंतु सही प्रति-ऑपरेशन हाताळणी हीच असते जी async Node कोडला मजबूत आणि डीबग्गेबल बनवते.