Why Error handling in async/await in Node.js? - Purpose & Use Cases

The Big Idea

What if you could catch async errors as easily as sync ones, making your code safer and simpler?

The Scenario

Imagine calling multiple APIs one after another and manually checking for errors after each call using nested callbacks or .then().catch() chains.

The Problem

Manual error checks get messy fast, making code hard to read and easy to break. You might miss errors or handle them inconsistently, causing bugs and crashes.

The Solution

Using async/await with try/catch blocks lets you write clear, linear code that handles errors gracefully and consistently, just like normal synchronous code.

Before vs After

✗ Before

fetchData().then(data => processData(data)).catch(err => console.error(err));

✓ After

try {
  const data = await fetchData();
  await processData(data);
} catch (err) {
  console.error(err);
}

What It Enables

This makes asynchronous code easier to write, read, and maintain while reliably catching errors.

Real Life Example

When building a web server, you can await database calls and handle any errors in one place, preventing server crashes and improving user experience.

Key Takeaways

Manual error handling in async code is complex and error-prone.

Async/await with try/catch simplifies error management.

It leads to cleaner, more reliable asynchronous programs.

Practice

1. What is the main purpose of using try/catch blocks with async/await in Node.js?

easy

A. To catch and handle errors from asynchronous operations

B. To speed up the execution of async functions

C. To convert async functions into synchronous ones

D. To automatically retry failed async operations

Solution

1. Step 1: Understand async/await behavior

   Async functions return promises and can throw errors when awaited operations fail.

2. Step 2: Role of try/catch

   Try/catch blocks catch these errors to prevent crashes and allow handling.

3. Final Answer:

   To catch and handle errors from asynchronous operations -> Option A

4. Quick Check:

   Error handling = A [OK]

Hint: Use try/catch around await to catch errors [OK]

Common Mistakes:

• Thinking async/await automatically handles errors
• Using try/catch outside async functions only
• Ignoring errors causing app crashes

2. Which of the following is the correct syntax to handle errors in an async function using async/await?

easy

A. async function fetchData() { try { await fetch(url); } catch (err) { console.error(err); } }

B. async function fetchData() { await fetch(url); }

C. async function fetchData() { try { fetch(url); } catch (err) { console.error(err); } }

D. async function fetchData() { await fetch(url).catch(console.error); }

Solution

1. Step 1: Check proper use of try/catch with await

   async function fetchData() { try { await fetch(url); } catch (err) { console.error(err); } } correctly wraps the await call inside try and catches errors.

2. Step 2: Identify incorrect patterns

   async function fetchData() { await fetch(url).catch(console.error); } uses .catch on await which is invalid syntax; async function fetchData() { try { fetch(url); } catch (err) { console.error(err); } } misses await; async function fetchData() { await fetch(url); } has no error handling.

3. Final Answer:

   async function fetchData() { try { await fetch(url); } catch (err) { console.error(err); } } -> Option A

4. Quick Check:

   Try/catch with await = D [OK]

Hint: Put await inside try block to catch errors [OK]

Common Mistakes:

• Using .catch() directly on await expression
• Forgetting to use await inside try
• Not catching errors at all

3. Consider this code snippet:

async function getData() {
  try {
    const response = await fetch('https://api.example.com/data');
    const data = await response.json();
    return data;
  } catch (error) {
    return 'Error occurred';
  }
}

getData().then(console.log);

What will be logged if the fetch fails due to network error?

medium

A. An unhandled promise rejection error

B. The raw error object

C. Undefined

D. 'Error occurred'

Solution

1. Step 1: Analyze try/catch behavior on fetch failure

   If fetch fails, control jumps to catch block which returns 'Error occurred'.

2. Step 2: Understand promise resolution

   getData returns a resolved promise with string 'Error occurred', so console.log prints that string.

3. Final Answer:

   'Error occurred' -> Option D

4. Quick Check:

   Catch returns string on error = B [OK]

Hint: Catch block return value is logged on error [OK]

Common Mistakes:

• Expecting unhandled error instead of caught return
• Confusing error object with returned string
• Ignoring async function returns promise

4. Identify the error in this async function:

async function loadUser() {
  try {
    const user = fetch('https://api.example.com/user');
    console.log(user.name);
  } catch (err) {
    console.error(err);
  }
}

medium

A. Incorrect catch block syntax

B. Missing await before fetch causing user to be a Promise

C. console.log should be inside catch block

D. fetch URL is invalid

Solution

1. Step 1: Check fetch usage

   fetch returns a Promise; without await, user is a Promise object, not the resolved data.

2. Step 2: Consequence of missing await

   Accessing user.name fails because user is not the actual data but a Promise.

3. Final Answer:

   Missing await before fetch causing user to be a Promise -> Option B

4. Quick Check:

   Await missing = A [OK]

Hint: Always await fetch to get resolved data before use [OK]

Common Mistakes:

• Forgetting await before async calls
• Assuming fetch returns data directly
• Misplacing console.log outside async flow

5. You want to fetch user data and then fetch posts by that user. Both calls can fail. How should you handle errors to ensure you catch failures in either step and log a clear message?

async function getUserPosts(userId) {
  // Your code here
}

hard

A. Use nested try/catch blocks: one for user fetch, one for posts fetch

B. Use .then().catch() chaining instead of async/await

C. Use a single try/catch wrapping both awaits for user and posts fetch

D. Ignore errors and let them crash the app

Solution

1. Step 1: Understand error flow in async/await

   A single try/catch can catch errors from any awaited call inside it.

2. Step 2: Simplify error handling

   Wrapping both awaits in one try/catch logs errors clearly without nesting complexity.

3. Final Answer:

   Use a single try/catch wrapping both awaits for user and posts fetch -> Option C

4. Quick Check:

   One try/catch covers multiple awaits = C [OK]

Hint: Wrap all awaits in one try/catch for simple error handling [OK]

Common Mistakes:

• Overcomplicating with nested try/catch
• Using .then().catch() mixing styles
• Not handling errors causing silent failures