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

Challenge - 5 Problems

🧠 Conceptual

intermediate

Why use try-catch blocks in Node.js?

What is the main reason to use try-catch blocks in Node.js code?

A To automatically fix bugs in the code

B To speed up the execution of asynchronous code

C To catch runtime errors and prevent the program from crashing unexpectedly

D To make the code run without any errors even if there are syntax mistakes

💡 Hint

Think about what happens when an error occurs during program execution.

Try-catch blocks help catch errors that happen while the program runs, so the program can handle them gracefully instead of crashing.

❓ component_behavior

intermediate

Output of unhandled promise rejection

What happens when a promise in Node.js is rejected but there is no catch handler?

Node.js

Promise.reject(new Error('Failed')).then(() => console.log('Success'));

A The program logs 'Success' and continues running

B Node.js emits an unhandledRejection warning and may crash depending on settings

C The program silently ignores the rejection and continues

D The program automatically retries the promise

💡 Hint

Think about what Node.js does when a promise rejection is not handled.

Node.js warns about unhandled promise rejections and depending on the version and settings, it may crash the process to avoid silent failures.

🔧 Debug

advanced

Identify the error handling mistake

What is wrong with this Node.js code snippet regarding error handling?

Node.js

const fs = require('fs');

fs.readFile('file.txt', (err, data) => {
  console.log(data.toString());
});

A It does not check for the error <code>err</code> before using <code>data</code>, which can cause a crash

B It uses a synchronous method instead of asynchronous

C It should use <code>try-catch</code> instead of a callback

D It logs the data twice

💡 Hint

Consider what happens if err is not null.

If err is not checked, the code might try to use data which could be undefined, causing a runtime error.

📝 Syntax

advanced

Correct syntax for async error handling

Which option correctly handles errors in an async function using try-catch in Node.js?

Node.js

async function fetchData() {
  // fetch data code
}

A

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

B

async function fetchData() {
  const data = await getData().catch(error => console.error(error));
  console.log(data);
}

C

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

D

async function fetchData() {
  const data = getData();
  console.log(data);
}

💡 Hint

Remember that await must be inside try to catch errors properly.

Option A correctly uses await inside a try block and catches errors in catch. Option A mixes await and catch incorrectly. Option A misses await. Option A has no error handling.

❓ state_output

expert

Effect of missing error handler on server state

Consider this Node.js Express server code snippet. What happens if next(error) is called but no error-handling middleware is defined?

Node.js

const express = require('express');
const app = express();

app.get('/', (req, res, next) => {
  const error = new Error('Something went wrong');
  next(error);
});

app.listen(3000);

A The request hangs and never gets a response

B The server ignores the error and responds with status 200

C The server crashes because the error is unhandled

D The server responds with a default 500 Internal Server Error page

💡 Hint

Express has a built-in error handler that handles errors passed to next(error) if no custom one is defined.

Express has a built-in error handler that responds with a default 500 Internal Server Error page when no custom error-handling middleware is defined.

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