Async/await error handling patterns in Node.js - Step-by-Step Execution

Concept Flow - Async/await error handling patterns

Start async function

↓

Try block: await async call

↓

Success?

No→Catch block: handle error

Yes↓

Continue execution

↓

End function

This flow shows how async functions use try/catch to handle errors from awaited calls, continuing smoothly if no error occurs.

Execution Sample

Node.js

async function fetchData() {
  try {
    const data = await getData();
    console.log('Data:', data);
  } catch (err) {
    console.error('Error:', err.message);
  }
}

This async function tries to get data and logs it; if an error happens, it catches and logs the error message.

Execution Table

Step	Action	Await Result	Error Thrown?	Branch Taken	Output
1	Call fetchData()	N/A	No	Enter try block	No output yet
2	Await getData()	Returns 'info'	No	Continue try block	No output yet
3	Log data	N/A	No	Try block success	Data: info
4	Function ends	N/A	No	Exit function	No output
5	Call fetchData() again	N/A	No	Enter try block	No output yet
6	Await getData()	Throws Error('fail')	Yes	Catch block runs	No output yet
7	Log error message	N/A	No	Catch block	Error: fail
8	Function ends	N/A	No	Exit function	No output

💡 Execution stops after function ends; errors are caught in catch block to prevent crashes.

Variable Tracker

Variable	Start	After Step 2	After Step 5	After Step 6	Final
data	undefined	'info'	undefined	undefined	undefined
err	undefined	undefined	undefined	Error('fail')	Error('fail')

Key Moments - 3 Insights

Why do we use try/catch with async/await instead of .then/.catch?

Try/catch lets us write asynchronous code that looks like normal code and handle errors in one place, as shown in steps 2-7 of the execution_table.

What happens if getData() throws an error inside await?

The error jumps to the catch block immediately, skipping the rest of the try block, as seen in steps 5-7.

Does the function stop running after an error is caught?

No, after catch finishes, the function ends normally without crashing, shown in step 8.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of 'data' after step 2?

A undefined

B 'info'

C Error object

D null

💡 Hint

Check the variable_tracker row for 'data' after step 2.

At which step does the catch block start running when an error occurs?

A Step 6

B Step 5

C Step 7

D Step 4

💡 Hint

Look at the execution_table where 'Error Thrown?' is Yes and 'Branch Taken' changes to catch block.

If getData() never throws an error, which steps will NOT happen?

A Steps 1-4

B Steps 2-3

C Steps 5-8

D Step 1 only

💡 Hint

Check the execution_table rows where 'Error Thrown?' is Yes.

Concept Snapshot

Async/await error handling uses try/catch blocks.
Inside try, await pauses for async calls.
If error occurs, catch runs to handle it.
This keeps code clean and prevents crashes.
Always wrap await calls in try/catch for safety.

Full Transcript

This lesson shows how to handle errors in Node.js async functions using async/await with try/catch. The flow starts by calling an async function that tries to await a promise. If the promise resolves successfully, the code continues and logs the data. If the promise rejects or throws an error, the catch block runs to handle the error gracefully. The execution table traces each step, showing when the function awaits, when errors occur, and how the catch block catches them. Variables like 'data' and 'err' change values depending on success or failure. Key moments clarify why try/catch is preferred with async/await, how errors jump to catch, and that the function ends normally after catching errors. The quiz tests understanding of variable states and flow steps. The snapshot summarizes the pattern: use try/catch around await to handle errors cleanly and keep your code safe.

Practice

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

easy

A. To handle errors that occur during asynchronous operations

B. To make the code run faster

C. To avoid using promises

D. To automatically retry failed operations

Solution

1. Step 1: Understand async/await behavior

   Async/await pauses code execution until a promise settles, but errors can still happen.

2. Step 2: Role of try/catch

   Try/catch blocks catch errors thrown inside async functions to prevent crashes.

3. Final Answer:

   To handle errors that occur during asynchronous operations -> Option A

4. Quick Check:

   Error handling = D [OK]

Hint: Use try/catch to catch async errors safely [OK]

Common Mistakes:

• Thinking try/catch makes code faster
• Believing async/await removes need for error handling
• Assuming errors auto-retry without code

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

easy

A. async function fetchData() { await fetch(); } catch (e) { console.error(e); }

B. async function fetchData() { (await fetch()).catch(e => console.error(e)); }

C. async function fetchData() { try { await fetch(); } catch (e) { console.error(e); } }

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

Solution

1. Step 1: Identify proper try/catch block usage

   Try/catch must wrap the await expression inside the async function body.

2. Step 2: Check syntax correctness

   async function fetchData() { try { await fetch(); } catch (e) { console.error(e); } } correctly places try before await and catch after the block.

3. Final Answer:

   async function fetchData() { try { await fetch(); } catch (e) { console.error(e); } } -> Option C

4. Quick Check:

   Correct try/catch syntax = C [OK]

Hint: Wrap await inside try block, catch errors after [OK]

Common Mistakes:

• Placing catch outside function body
• Using .catch() on await directly
• Using try without braces

3. What will be logged to the console when running this code?

async function test() {
  try {
    await Promise.reject('fail');
  } catch (error) {
    console.log('Caught:', error);
  }
}
test();

medium

A. fail

B. Caught: fail

C. Uncaught (in promise) fail

D. No output

Solution

1. Step 1: Understand Promise.reject inside try block

   The rejected promise throws an error caught by the catch block.

2. Step 2: Check console.log output

   The catch block logs 'Caught:' followed by the error message 'fail'.

3. Final Answer:

   Caught: fail -> Option B

4. Quick Check:

   Error caught and logged = B [OK]

Hint: Rejected promises inside try are caught by catch [OK]

Common Mistakes:

• Expecting unhandled rejection error
• Thinking error is logged without 'Caught:' prefix
• Assuming no output because of rejection

4. Identify the error in this async function error handling code:

async function load() {
  try {
    const data = await fetchData();
  } catch {
    console.error(error);
  }
}

medium

A. console.error cannot log variables

B. Await cannot be used inside try block

C. fetchData() must be awaited outside try

D. Missing error parameter in catch block

Solution

1. Step 1: Check catch block syntax

   The catch block is missing the error parameter to receive the thrown error.

2. Step 2: Understand console.error usage

   console.error(error) references a variable 'error' which is undefined without catch parameter.

3. Final Answer:

   Missing error parameter in catch block -> Option D

4. Quick Check:

   Catch needs error param = A [OK]

Hint: Always name error in catch(e) to use it inside [OK]

Common Mistakes:

• Omitting error parameter in catch
• Misplacing await outside try
• Misusing console.error syntax

5. You want to run multiple async tasks in parallel and handle errors individually without stopping all tasks. Which pattern correctly handles errors for each async call using async/await?

hard

A. Wrap each await call inside its own try/catch block

B. Use Promise.all with a single try/catch around it

C. Use await inside a forEach loop with one try/catch outside

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

Solution

1. Step 1: Understand parallel async calls and error handling

   Promise.all stops on first rejection; one try/catch around it catches all or none.

2. Step 2: Individual error handling requires separate try/catch

   Wrapping each await in its own try/catch lets errors be handled separately without stopping others.

3. Final Answer:

   Wrap each await call inside its own try/catch block -> Option A

4. Quick Check:

   Individual error handling = A [OK]

Hint: Try/catch each await separately for independent error handling [OK]

Common Mistakes:

• Using Promise.all with one try/catch stops all on first error
• Using forEach with await causes unexpected behavior
• Ignoring errors leads to crashes or silent failures