Promise catch for async errors in Node.js - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output when a rejected promise is caught?

Consider this Node.js code snippet using promises. What will be logged to the console?

Node.js

const promise = new Promise((resolve, reject) => {
  reject('Error occurred');
});
promise.catch(error => console.log('Caught:', error));

A Uncaught (in promise) Error occurred

B Caught: Error occurred

C Nothing is logged

D SyntaxError

💡 Hint

Remember that .catch handles rejected promises.

The promise is rejected with 'Error occurred'. The .catch method catches this rejection and logs the message with 'Caught:'.

📝 Syntax

intermediate

Which option correctly catches errors from an async function?

Given an async function that may throw an error, which code snippet correctly catches the error using promises?

Node.js

async function fetchData() {
  throw new Error('Failed to fetch');
}

// Which option correctly catches the error?

A fetchData().catch(err => console.log('Error:', err.message));

B fetchData().catch(err => console.log('Success:', err.message));

C try { fetchData(); } catch(err) { console.log('Error:', err.message); }

D fetchData().then(err => console.log('Error:', err.message));

💡 Hint

Promises use .catch to handle errors, not .then or try/catch directly.

Calling fetchData() returns a promise. Using .catch handles any rejection. Option A correctly logs the error message.

🔧 Debug

advanced

Why does this promise catch block not handle the error?

Look at this code. Why is the error not caught by the .catch block?

Node.js

const promise = new Promise((resolve, reject) => {
  setTimeout(() => {
    throw new Error('Delayed error');
  }, 100);
});
promise.catch(err => console.log('Caught:', err.message));

A The promise is never rejected explicitly, so .catch does not run.

B The .catch block is missing a return statement.

C The setTimeout callback prevents the promise from resolving.

D The error is thrown outside the promise executor, so it is uncaught by .catch.

💡 Hint

Errors thrown asynchronously inside setTimeout are not caught by the promise unless rejected explicitly.

Throwing an error inside setTimeout does not reject the promise. The promise executor finishes without rejection, so .catch is never triggered.

❓ state_output

advanced

What is the final value of 'result' after promise chaining with catch?

Analyze this code and determine the final value of the variable 'result'.

Node.js

let result = '';
Promise.resolve('start')
  .then(value => {
    result += value + '-then1-';
    throw new Error('fail');
  })
  .catch(err => {
    result += 'catch-';
    return 'recovered';
  })
  .then(value => {
    result += value + '-then2';
  });

A start-then1-then2

B start-then1-catch-then2

C start-then1-catch-recovered-then2

D catch-recovered-then2

💡 Hint

Remember that catch returns a value that the next then receives.

The first then appends 'start-then1-' then throws. The catch appends 'catch-' and returns 'recovered'. The next then appends 'recovered-then2'.

🧠 Conceptual

expert

Which statement about Promise.catch and async/await error handling is true?

Select the correct statement about how Promise.catch and async/await handle errors in Node.js.

A Promise.catch handles rejected promises, while async/await requires try/catch blocks to handle errors.

B Promise.catch automatically retries the async function on error, async/await does not.

C Async/await does not support error handling; only Promise.catch can catch errors.

D Promise.catch can only catch synchronous errors, async/await catches asynchronous errors.

💡 Hint

Think about how errors are caught in promises vs async/await syntax.

Promise.catch is a method to handle rejected promises. Async/await syntax requires try/catch blocks to handle errors thrown inside async functions.