Unhandled rejection handling in Node.js - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

What happens when a Promise rejection is not handled?

Consider a Node.js program where a Promise is rejected but no catch or rejection handler is attached. What is the typical behavior?

A Node.js emits an <code>unhandledRejection</code> event but does not terminate the process by default.

B Node.js immediately crashes with a fatal error.

C The program silently ignores the rejection and continues running.

D The rejection is automatically retried until it succeeds.

💡 Hint

Think about how Node.js informs you about unhandled promise rejections before deciding what to do.

Node.js emits an unhandledRejection event when a Promise is rejected without a handler. By default, it logs a warning but does not crash the process immediately.

❓ component_behavior

intermediate

What is the output of this unhandled rejection handler code?

Given the following Node.js code, what will be printed to the console?

Node.js

process.on('unhandledRejection', (reason, promise) => {
  console.log('Unhandled Rejection at:', promise, 'reason:', reason.message);
});

Promise.reject(new Error('Fail!'));

A SyntaxError due to incorrect event handler syntax.

B Unhandled Rejection at: undefined reason: Fail!

C No output, the rejection is handled silently.

D Unhandled Rejection at: [object Promise] reason: Fail!

💡 Hint

Look at the parameters passed to the unhandledRejection event handler.

The event handler receives the rejected Promise and the reason (Error object). Logging them shows the Promise object and the error message.

🔧 Debug

advanced

Why does this unhandled rejection handler not catch the error?

Examine this code snippet. Why does the unhandledRejection event not trigger?

Node.js

process.on('unhandledRejection', (reason) => {
  console.log('Caught:', reason.message);
});

const p = Promise.reject(new Error('Oops!'));
p.catch(() => {});

A The event handler is missing the second parameter, so it fails silently.

B Because the Promise has a catch handler, the rejection is considered handled and no event is emitted.

C The event name is misspelled, so it never triggers.

D Promises rejected inside event handlers do not emit unhandledRejection.

💡 Hint

Think about when Node.js emits the unhandledRejection event.

If a Promise rejection is handled by a catch or then handler, Node.js does not emit the unhandledRejection event.

📝 Syntax

advanced

Which option correctly attaches a global unhandled rejection handler?

Choose the code snippet that correctly listens for unhandled Promise rejections in Node.js.

A process.addListener('unhandledRejection', reason => console.log(reason));

B process.onUnhandledRejection((reason) => console.log(reason));

C process.on('unhandledRejection', (reason, promise) => { console.log(reason); });

D process.handle('unhandledRejection', (reason) => console.log(reason));

💡 Hint

Recall the correct Node.js API for event listening on process.

The correct method is process.on(eventName, callback). Options C and D use invalid method names.

❓ lifecycle

expert

What is the effect of calling process.exit() inside an unhandled rejection handler?

Consider this code snippet:

process.on('unhandledRejection', (reason) => {
  console.error('Error:', reason.message);
  process.exit(1);
});

Promise.reject(new Error('Critical failure'));

What happens when this code runs?

A The error message is logged, and the Node.js process exits immediately with code 1.

B The error message is logged, but the process continues running normally.

C The unhandledRejection event is ignored because <code>process.exit()</code> is called.

D The process crashes with an unhandled exception error before logging.

💡 Hint

Think about what process.exit() does inside event handlers.

Calling process.exit(1) stops the Node.js process immediately after logging the error.