Why robust error handling matters in Node.js - Test Your Understanding

Practice - 5 Tasks

1fill in blank

easy

Complete the code to catch errors in an async function.

Node.js

async function fetchData() {
  try {
    const response = await fetch('https://api.example.com/data');
    const data = await response.json();
    return data;
  } catch ([1]) {
    console.error('Error fetching data:', error);
  }
}

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

Aerr

Bexception

Ce

Derror

Attempts:

3 left

💡 Hint

Common Mistakes

Using a different variable name in catch than inside the block.

The catch block uses the variable error to hold the caught error. This variable is then used inside the block.

2fill in blank

medium

Complete the code to throw a custom error when a condition fails.

Node.js

function checkAge(age) {
  if (age < 18) {
    throw new [1]('Age must be at least 18');
  }
  return true;
}

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

AException

BError

CTypeError

DRangeError

Attempts:

3 left

💡 Hint

Common Mistakes

Using non-existent error classes like Exception.

Throwing a new Error object is the standard way to create custom errors in JavaScript.

3fill in blank

hard

Fix the error in the code to properly handle errors in a promise chain.

Node.js

fetch('https://api.example.com/data')
  .then(response => response.json())
  .then(data => console.log(data))
  .catch([1] => console.error('Fetch error:', err));

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

Aerr

Be

Cerror

Dexception

Attempts:

3 left

💡 Hint

Common Mistakes

Using a different variable name than inside the catch function.

The catch block uses err as the parameter, which matches the variable used inside the arrow function.

4fill in blank

hard

Fill both blanks to create a try-catch block that logs the error message and rethrows the error.

Node.js

try {
  JSON.parse('[1]');
} catch ([2]) {
  console.error([2].message);
  throw [2];
}

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

A"{ invalid json }"

Berror

Cerr

D"{ key: 'value' }"

Attempts:

3 left

💡 Hint

Common Mistakes

Using valid JSON string so no error occurs.

Mismatch between catch parameter and usage.

The string "{ invalid json }" is invalid JSON and will cause an error. The catch block uses error to log and rethrow the error.

5fill in blank

hard

Fill all three blanks to create a function that handles errors and returns a default value.

Node.js

async function getUser(id) {
  try {
    const response = await fetch(`/users/$[1]`);
    if (!response.ok) throw new Error('User not found');
    return await response.json();
  } catch ([2]) {
    console.error([2].message);
    return [3];
  }
}

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

Aid

Berror

C{}

DuserId

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong variable names in URL or catch.

Returning undefined instead of a default value.

The function uses id in the URL, catches errors with error, logs the message, and returns an empty object {} as a default value.

Practice

1. Why is robust error handling important in Node.js applications?

easy

A. It hides all errors so users never see any messages.

B. It makes the code run faster by skipping error checks.

C. It prevents the application from crashing unexpectedly and improves user experience.

D. It automatically fixes bugs without developer intervention.

Solution

1. Step 1: Understand the role of error handling

   Error handling helps catch problems before they crash the app, keeping it stable.

2. Step 2: Consider user experience

   Good error handling shows clear messages, so users know what happened and can continue safely.

3. Final Answer:

   It prevents the application from crashing unexpectedly and improves user experience. -> Option C

4. Quick Check:

   Stable app + good UX = C [OK]

Hint: Error handling keeps apps stable and users happy [OK]

Common Mistakes:

• Thinking error handling speeds up code
• Believing errors should be hidden completely
• Assuming errors fix themselves automatically

2. Which of the following is the correct syntax to catch errors in Node.js?

easy

A. try { /* code */ } catch (error) { /* handle error */ }

B. try: { /* code */ } except (error) { /* handle error */ }

C. catch { /* code */ } try (error) { /* handle error */ }

D. handle error { /* code */ } try { /* code */ }

Solution

1. Step 1: Recall Node.js error handling syntax

   Node.js uses JavaScript's standard try { } catch (error) { } structure.

2. Step 2: Identify correct syntax among options

   Only try { /* code */ } catch (error) { /* handle error */ } matches the correct JavaScript syntax for error catching.

3. Final Answer:

   try { /* code */ } catch (error) { /* handle error */ } -> Option A

4. Quick Check:

   Correct try-catch syntax = A [OK]

Hint: Remember try-catch blocks use parentheses for error [OK]

Common Mistakes:

• Using Python-like syntax (try: except)
• Swapping try and catch keywords
• Omitting parentheses around error

3. What will be the output of this Node.js code?

try {
  throw new Error('Oops!');
} catch (e) {
  console.log('Caught:', e.message);
} finally {
  console.log('Done');
}

medium

A. Caught: Oops!\nDone

B. Done\nCaught: Oops!

C. Oops!\nDone

D. Error: Oops!\nDone

Solution

1. Step 1: Understand the try-catch-finally flow

   The throw triggers an error caught by catch, which logs 'Caught: Oops!'.

2. Step 2: Recognize finally block runs last

   The finally block always runs, logging 'Done' after the catch.

3. Final Answer:

   Caught: Oops!\nDone -> Option A

4. Quick Check:

   Catch logs error, finally logs done = A [OK]

Hint: Catch runs before finally; order matters [OK]

Common Mistakes:

• Thinking finally runs before catch
• Expecting error to crash program
• Confusing error message with error object

4. Identify the error in this Node.js code snippet:

try {
  console.log('Start');
  throw 'Error happened';
} catch {
  console.log('Caught an error');
}

medium

A. Throwing a string instead of an Error object is invalid.

B. Missing error parameter in catch block parentheses.

C. The try block must not contain console.log statements.

D. Catch block must be followed by finally block.

Solution

1. Step 1: Check catch block syntax

   In Node.js, catch must have parentheses with an error parameter, e.g., catch (error).

2. Step 2: Validate other parts

   Throwing a string is allowed, console.log is fine, and finally is optional.

3. Final Answer:

   Missing error parameter in catch block parentheses. -> Option B

4. Quick Check:

   Catch needs error param = B [OK]

Hint: Catch always needs (error) parameter in Node.js [OK]

Common Mistakes:

• Thinking catch can omit error parameter
• Believing throw must use Error object only
• Assuming finally block is mandatory

5. You have a Node.js function that reads a file and processes its content. Which approach best ensures robust error handling to keep the app stable and inform users properly?

hard

A. Use multiple nested try blocks without catch to isolate errors.

B. Ignore errors during file reading to avoid interrupting the process.

C. Only catch errors during processing, not during file reading.

D. Use try-catch around file reading and processing, log errors clearly, and send user-friendly messages.

Solution

1. Step 1: Identify where errors can occur

   Errors may happen during file reading or processing, so both need handling.

2. Step 2: Choose error handling strategy

   Using try-catch around both ensures catching all errors, logging them, and informing users clearly.

3. Final Answer:

   Use try-catch around file reading and processing, log errors clearly, and send user-friendly messages. -> Option D

4. Quick Check:

   Catch all errors + clear logs + user messages = D [OK]

Hint: Catch all errors and inform users clearly [OK]

Common Mistakes:

• Ignoring errors thinking they are rare
• Catching only some errors, missing others
• Using try without catch blocks