તમે 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
```

જો `.catch` નથી (અથવા `await` ની આસપાસ try/catch નથી) Promise અસ્વીકૃતિ છે તો તે **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 કોડને મજબૂત અને ડીબગેબલ બનાવે છે.