A hibakezelés az async stílustól függ, és ha rosszul csinálod, csendes hibákhoz vagy összeomlásokhoz vezethet. A kulcsszabályok: használj try/catch-t az async/await-tel, mindig kezeld a Promise elutasítást, és soha ne hagyd, hogy az async callback-ek hibái kezeletlen maradjanak.
() {
{
user = db.(id);
user;
} (err) {
logger.(err);
(, { : err });
}
}
fetchData()
.then(process)
.catch(err => logger.error(err)); // an unhandled rejection can crash the process
A Promise elutasítása, ha nincs .catch (vagy nincs try/catch az await körül), kezeletlen elutasítássá válik — ami a modern Node-ban leállítja a folyamatot.
// ❌ try/catch does NOT catch this — the throw happens on a LATER tick
try {
setTimeout(() => { throw new Error("boom"); }, 100);
} catch (e) { /* never runs */ }
A try/catch csak az aktuális szinkron hívási veremben lévő hibákat fogja meg. Amikor az időzítő/callback fut, a try blokk már rég eltűnt. Kezeld a hibát a callback belsejében.
// ❌ 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); });
Ezek a hibanapló és (kezeletlen kivételekhez) a tiszta leállítás biztonsági hálói — nem helyettesítik a hibák kezelését, ahol előfordulnak.
A kezeletlen async hibák az okok között vezetik a listát azoknak az Node-szolgáltatásoknak, amelyek meghiúsultak vagy csendes meghibásodást szenvedtek.
A szabályok elsajátítása — try/catch az await körül, mindig .catch a Promise-ekhez, hibákat kezeld az async callback-ek belsejében (a try/catch nem tudja elérni őket), és csomagold be az Express async kezelőket a hibák továbbítása érdekében — megakadályozza a függő kéréseket, a csendes hibákat és a folyamatok összeomlása.
A globális kezelők végső biztonsági hálót biztosítanak, de a helyes операций szerinti kezelés az, ami az async Node kódot robusztussá és debugelhetővé teszi.