Error handling in async/await in Node.js - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What happens when an async function throws an error without try/catch?

Consider this async function in Node.js. What will be the output when calling fetchData() without a try/catch block?

Node.js

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

fetchData();

A A warning appears in the console about an unhandled promise rejection.

B The program crashes immediately with an uncaught exception error.

C The error is silently ignored and no output appears.

D The function returns undefined without any error.

💡 Hint

Think about how Node.js handles promises that reject but are not caught.

When an async function throws an error and the returned promise is not handled with catch, Node.js emits a warning about an unhandled promise rejection. It does not crash immediately but warns the developer.

📝 Syntax

intermediate

Which option correctly catches errors in async/await?

You want to catch errors thrown inside an async function. Which code snippet correctly handles errors?

Node.js

async function getUser() {
  // fetch user data
}

// How to call getUser with error handling?

A

try {
  const user = await getUser();
} catch (error) {
  console.error(error);
}

B getUser().catch(error => console.error(error));

C

try {
  getUser().catch(error => console.error(error));
} catch (error) {
  console.error(error);
}

D await getUser().catch(error => console.error(error));

💡 Hint

Remember that await must be inside an async function and try/catch is used to catch errors.

Option A uses try/catch with await inside an async function, which is the standard way to catch errors synchronously. Option A works but does not use await. Option A is redundant and incorrect syntax. Option A is invalid outside async functions.

🔧 Debug

advanced

Why does this async function not catch the error as expected?

Look at the code below. Why does the error not get caught by the catch block?

Node.js

async function process() {
  try {
    setTimeout(() => {
      throw new Error('Timeout error');
    }, 100);
  } catch (e) {
    console.log('Caught:', e.message);
  }
}

process();

A Because setTimeout does not allow errors to be caught by try/catch.

B Because async functions cannot catch errors from setTimeout callbacks.

C Because the error is thrown inside a callback, outside the try block's synchronous scope.

D Because the catch block is missing an await keyword.

💡 Hint

Think about how try/catch works with asynchronous callbacks.

The error is thrown asynchronously inside the setTimeout callback, which runs after the try block has finished. So the catch block does not catch it. Errors in async callbacks need separate handling.

❓ state_output

advanced

What is the output of this async/await error handling code?

Analyze the code and select the console output.

Node.js

async function test() {
  try {
    await Promise.reject('Oops');
  } catch (e) {
    console.log('Error:', e);
  } finally {
    console.log('Done');
  }
}

test();

A Done

B Done\nError: Oops

C Error: Oops

D Error: Oops\nDone

💡 Hint

Remember the order of try/catch/finally execution.

The catch block logs the error first, then the finally block runs and logs 'Done'. So the output is 'Error: Oops' followed by 'Done'.

🧠 Conceptual

expert

Which statement about async/await error handling is true?

Select the only true statement about error handling with async/await in Node.js.

A Unhandled promise rejections from async functions will always terminate the Node.js process immediately.

B Using try/catch inside async functions allows synchronous-style error handling for asynchronous code.

C Await expressions automatically log errors to the console if not caught.

D Errors thrown inside async functions must always be caught with try/catch; otherwise, the program crashes immediately.

💡 Hint

Think about how async/await simplifies error handling compared to raw promises.

Try/catch inside async functions lets you handle errors like synchronous code, making async code easier to read and maintain. The other statements are false regarding Node.js behavior.