ਗਲਤੀ ਸੰਭਾਲਣਾ async ਸ਼ੈਲੀ ਦੁਆਰਾ ਵੱਖ-ਵੱਖ ਹੁੰਦਾ ਹੈ, ਅਤੇ ਇਹ ਗਲਤ ਕਰਨ ਨਾਲ ਸ਼ਾਂਤ ਵਿਫਲਤਾਵਾਂ ਜਾਂ ਕ੍ਰੈਸ਼ ਹੁੰਦੀ ਹੈ। ਮੁੱਖ ਨਿਯਮ: async/await ਦੇ ਨਾਲ try/catch ਵਰਤੋ, ਹਮੇਸ਼ਾ Promise rejections ਨੂੰ ਸੰਭਾਲੋ, ਅਤੇ async callbacks ਵਿੱਚ ਗਲਤੀਆਂ ਨੂੰ ਕਦੇ ਵੀ ਅਸੰਭਾਲੀ ਨਾ ਛੱਡੋ।
try/catch ਵਰਤੋ () {
{
user = db.(id);
user;
} (err) {
logger.(err);
(, { : err });
}
}
.catchfetchData()
.then(process)
.catch(err => logger.error(err)); // an unhandled rejection can crash the process
ਇੱਕ Promise rejection ਜਿਸ ਕੋਲ ਕੋਈ .catch (ਜਾਂ await ਦੁਆਲੇ ਕੋਈ try/catch) ਨਹੀਂ ਹੈ, ਇੱਕ unhandled rejection ਬਣ ਜਾਂਦਾ ਹੈ — ਜੋ ਆਧੁਨਿਕ Node ਵਿੱਚ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਖਤਮ ਕਰਦਾ ਹੈ।
// ❌ 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 ਸਿਰਫ ਮੌਜੂਦਾ synchronous call stack ਵਿੱਚ ਗਲਤੀਆਂ ਨੂੰ ਫੜਦਾ ਹੈ। ਜਦੋਂ ਟਾਈਮਰ/callback ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ, try ਬਲਾਕ ਬਹੁਤ ਪਹਿਲਾਂ ਚਲਾ ਜਾਂਦਾ ਹੈ। ਗਲਤੀ ਨੂੰ callback ਦੇ ਅੰਦਰ ਸੰਭਾਲੋ।
// ❌ 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
}));
process.on("unhandledRejection", (reason) => { logger.error(reason); });
process.on("uncaughtException", (err) => { logger.error(err); process.exit(1); });
ਇਹ safety nets ਹਨ ਲਾਗ ਕਰਨ ਅਤੇ (ਅਸੰਭਾਲੀ ਗਲਤੀਆਂ ਲਈ) ਸਾਫ਼ ਤਰੀਕੇ ਨਾਲ ਬਾਹਰ ਨਿਕਲਣ ਲਈ — ਉਹਨਾਂ ਦੀ ਥਾਂ ਅਨੁਸਾਰ ਗਲਤੀਆਂ ਨੂੰ ਸੰਭਾਲਣ ਦੀ ਜਗਾ ਨਹੀਂ ਹੈ।
Unhandled async ਗਲਤੀਆਂ Node ਸੇਵਾਵਾਂ ਦੇ ਕ੍ਰੈਸ਼ ਜਾਂ ਤੇ ਚੁੱਪਚਾਪ ਟੁੱਟਣ ਦਾ ਇੱਕ ਪ੍ਰਮੁੱਖ ਕਾਰਨ ਹਨ।
ਨਿਯਮਾਂ ਵਿੱਚ ਮੁਹਾਰਤ ਹਾਸਲ ਕਰਨਾ — await ਦੁਆਲੇ try/catch, ਹਮੇਸ਼ਾ Promises ਨੂੰ .catch, async callbacks ਦੇ ਅੰਦਰ ਗਲਤੀਆਂ ਨੂੰ ਸੰਭਾਲੋ (try/catch ਉਹਨਾਂ ਤੱਕ ਨਹੀਂ ਪਹੁੰਚ ਸਕਦਾ), ਅਤੇ Express async handlers ਨੂੰ errors ਨੂੰ ਅੱਗੇ ਭੇਜਣ ਲਈ wrap ਕਰੋ — hanging requests, silent failures, ਅਤੇ process crashes ਨੂੰ ਰੋਕਦਾ ਹੈ।
Global handlers ਇੱਕ ਅੰਤਮ safety net ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਨ, ਪਰ ਸਹੀ per-operation handling ਹੀ async Node ਕੋਡ ਨੂੰ ਮਜ਼ਬੂਤ ਅਤੇ debuggable ਬਣਾਉਂਦੀ ਹੈ।