La gestion des erreurs diffère selon le style async, et mal le faire provoque des défaillances silencieuses ou des crashes. Les règles clés : utilisez try/catch avec async/await, gérez toujours les Promise rejections, et ne laissez pas les erreurs dans les async callbacks s'échapper sans être traitées.
() {
{
user = db.(id);
user;
} (err) {
logger.(err);
(, { : err });
}
}
fetchData()
.then(process)
.catch(err => logger.error(err)); // an unhandled rejection can crash the process
Un rejet de Promise sans .catch (ou sans try/catch autour de await) devient un rejet non géré — ce qui dans Node moderne termine le processus.
// ❌ 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 ne capture que les erreurs dans la pile d'appels synchrone actuelle. Au moment où le minuteur/callback s'exécute, le bloc try est depuis longtemps parti. Gérez l'erreur à l'intérieur du 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
}));
Les erreurs async non gérées sont l'une des principales causes de crash ou de défaillance silencieuse des services Node.
Maîtriser les règles — try/catch autour de await, toujours .catch pour les Promises, gérer les erreurs à l'intérieur des async callbacks (try/catch ne peut pas les atteindre), et envelopper les gestionnaires async d'Express pour transmettre les erreurs — prévient les requêtes bloquées, les défaillances silencieuses et les crashes de processus.
Les gestionnaires globaux fournissent un filet de sécurité final, mais la gestion correcte par opération est ce qui rend le code async Node robuste et débogable.
process.on("unhandledRejection", (reason) => { logger.error(reason); });
process.on("uncaughtException", (err) => { logger.error(err); process.exit(1); });
Ce sont des filets de sécurité pour journaliser et (pour les exceptions non capturées) quitter proprement — pas un substitut à la gestion des erreurs là où elles se produisent.