Async/await error handling patterns in Node.js - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to catch errors using try/catch with async/await.

Node.js

async function fetchData() {
  try {
    const data = await fetch('[1]');
    return data.json();
  } catch (error) {
    console.error('Error:', error);
  }
}

Drag options to blanks, or click blank then click option'

A'https://api.example.com/data'

Bfetch('https://api.example.com/data')

Cawait fetch('https://api.example.com/data')

D'data'

Attempts:

3 left

💡 Hint

Common Mistakes

Passing the fetch call itself instead of the URL string.

Forgetting to put the URL inside quotes.

The fetch function needs a URL string as argument. Here, the URL is passed as a string inside quotes.

2fill in blank

medium

Complete the code to rethrow an error after logging it inside a catch block.

Node.js

async function getUser() {
  try {
    const response = await fetch('/user');
    return await response.json();
  } catch (error) {
    console.error('Fetch failed:', error);
    [1];
  }
}

Drag options to blanks, or click blank then click option'

Areturn error

Bthrow new Error()

Cthrow error

Dconsole.log(error)

Attempts:

3 left

💡 Hint

Common Mistakes

Returning the error instead of throwing it.

Throwing a new empty error losing original info.

To pass the error up the call stack after logging, use throw error.

3fill in blank

hard

Fix the error in this async function by adding proper error handling.

Node.js

async function loadData() {
  const response = await fetch('/data');
  const json = await response.json();
  return json;
  [1]
}

Drag options to blanks, or click blank then click option'

Atry { const response = await fetch('/data'); const json = await response.json(); return json; } catch (error) { console.error(error); }

Btry { } catch (error) { console.error(error); }

Cfinally { console.log('Done'); }

Dcatch (error) { console.error(error); }

Attempts:

3 left

💡 Hint

Common Mistakes

Adding catch block outside function body.

Using finally without try/catch.

Not wrapping await calls in try/catch.

To handle errors in async/await, wrap the await calls inside a try/catch block.

4fill in blank

hard

Fill both blanks to create an async function that returns null on error instead of throwing.

Node.js

async function safeFetch() {
  try {
    const response = await fetch('[1]');
    return await response.json();
  } catch ([2]) {
    return null;
  }
}

Drag options to blanks, or click blank then click option'

A'/safe-data'

Berr

Cerror

D'/data'

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong URL string.

Missing error variable in catch.

The function fetches from '/safe-data' and catches errors using the variable named error.

5fill in blank

hard

Fill all three blanks to create an async function that logs error message and returns fallback data.

Node.js

async function fetchWithFallback() {
  try {
    const res = await fetch('[1]');
    if (!res.ok) throw new Error(res.statusText);
    return await res.json();
  } catch ([2]) {
    console.error('Fetch error:', [3].message);
    return { data: [] };
  }
}

Drag options to blanks, or click blank then click option'

A'/api/items'

Berr

Cerror

De

Attempts:

3 left

💡 Hint

Common Mistakes

Using different variable names in catch and console.error.

Not checking response status before parsing JSON.

The function fetches from '/api/items', catches errors as err, logs err.message, and returns fallback data.

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