Async/await error handling patterns in Node.js - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output of this async function with try/catch?

Consider this Node.js async function. What will it print to the console when called?

Node.js

async function fetchData() {
  try {
    const data = await Promise.reject(new Error('Failed'));
    console.log('Data:', data);
  } catch (error) {
    console.log('Caught:', error.message);
  }
}
fetchData();

A Uncaught (in promise) Error: Failed

B Data: undefined

C Caught: Failed

D No output

💡 Hint

Think about what happens when a promise rejects inside a try block with await.

The rejected promise throws an error caught by the catch block, so it logs 'Caught: Failed'.

📝 Syntax

intermediate

Which option correctly handles errors with async/await?

Which code snippet correctly catches errors from an async function call?

Node.js

async function getUser() {
  throw new Error('User not found');
}
// Which option below correctly handles errors?

A try { await getUser(); } catch (error) { console.log('Error:', error.message); }

B try { getUser(); } catch (error) { console.log('Error:', error.message); }

C await getUser().catch(error => console.log('Error:', error.message));

D getUser().catch(error => console.log('Error:', error.message));

💡 Hint

Remember that await must be inside an async function to use try/catch.

Only option A uses await inside try/catch correctly to catch async errors.

🔧 Debug

advanced

Why does this async function not catch the error?

Identify why the error is not caught in this code snippet.

Node.js

async function load() {
  try {
    Promise.reject(new Error('Oops'));
  } catch (e) {
    console.log('Caught:', e.message);
  }
}
load();

A Because try/catch cannot catch errors from Promise.reject at all.

B Because Promise.reject is not awaited, so error is unhandled outside try/catch.

C Because the error message is empty, so nothing is logged.

D Because load() is not awaited, so errors are ignored.

💡 Hint

Think about how async errors propagate when not awaited.

Without await, the rejected promise runs asynchronously and is not caught by try/catch.

❓ state_output

advanced

What is the console output of this async/await with nested try/catch?

Analyze the output of this code snippet:

Node.js

async function test() {
  try {
    try {
      await Promise.reject('Fail');
    } catch (e) {
      console.log('Inner catch:', e);
      throw new Error('New error');
    }
  } catch (e) {
    console.log('Outer catch:', e.message);
  }
}
test();

A Inner catch: Fail

B Outer catch: Fail

C No output

D

Inner catch: Fail
Outer catch: New error

💡 Hint

Look at how errors are re-thrown and caught by outer catch.

The inner catch logs 'Fail' then throws a new error caught by outer catch logging 'New error'.

🧠 Conceptual

expert

Which pattern best ensures all async errors are caught in a Node.js app?

Choose the best pattern to handle errors from multiple async calls in a function.

A Wrap all awaits in a single try/catch block to catch any error thrown.

B Use multiple try/catch blocks around each await call separately.

C Use .then().catch() chaining for each async call instead of async/await.

D Ignore errors and rely on process.on('unhandledRejection') to catch them.

💡 Hint

Think about clean and centralized error handling with async/await.

A single try/catch around multiple awaits cleanly catches any error thrown by them.