All 15 Async Patterns questions
More in Async Patterns
How do you implement a retry-with-exponential-backoff pattern for a flaky async operation in Node.js? What is util.promisify(), and when would you still need it in modern Node.js? What is the difference between micro tasks and macro tasks in Node.js's event loop, and how does this affect Promise callback ordering? What is an async generator, and how does 'for await...of' let you consume asynchronously produced data? What is a common pitfall when using async/await inside Array.prototype.forEach(), and how do you fix it? How would you implement a concurrency-limited task queue in Node.js to process many async tasks without overwhelming a downstream resource? What is 'fire-and-forget' async code, and why is it generally discouraged in production Node.js applications?
Advertisement
Back to results for “Debugging & Diagnostics”
Node.js › Async Patterns

What is the difference between an unhandled promise rejection and an uncaught exception in Node.js, and how does Node handle each by default?

Advanced

Answer

An uncaught exception is a synchronous throw that propagates all the way up without being caught, which crashes the Node.js process immediately by default (via the 'uncaughtException' event, which should only ever be used for cleanup/logging before exiting, never to keep the process alive). An unhandled promise rejection happens when a rejected promise has no .catch() handler attached anywhere in its chain -- historically this only printed a warning, but as of modern Node.js versions the default behavior is to also terminate the process (configurable via the --unhandled-rejections flag), treating it with the same seriousness as an uncaught exception.
process.on('uncaughtException', (err) => {
  console.error('Uncaught exception, shutting down:', err);
  process.exit(1); // cleanup only, never suppress and continue
});

process.on('unhandledRejection', (reason) => {
  console.error('Unhandled rejection:', reason);
  process.exit(1);
});
Real-world example A production incident where a service silently stopped processing jobs (rather than crashing loudly) is traced to an unhandled promise rejection inside a fire-and-forget async call; adding a process-level unhandledRejection handler that logs and exits ensures future occurrences fail loudly and get restarted by the process manager instead of hanging silently.

Common follow-ups: Why is it considered bad practice to use these handlers to simply swallow the error and let the process keep running?;How do you prevent a specific promise from ever becoming an unhandled rejection in the first place?

Error Handling;Debugging & Diagnostics
All 15 Async Patterns questions