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.