Centralized error handling in Node.js - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

What is the main benefit of centralized error handling in Node.js?

Consider a Node.js app with many routes and asynchronous operations. What is the main benefit of using centralized error handling middleware?

A It allows handling all errors in one place, reducing repeated code and improving maintainability.

B It automatically fixes all runtime errors without developer intervention.

C It prevents errors from occurring by validating all inputs before processing.

D It speeds up the application by skipping error checks in individual routes.

💡 Hint

Think about how many places you would need to write error handling code without centralization.

Centralized error handling middleware in Node.js collects errors from different parts of the app and processes them in one place. This reduces repeated code and makes maintenance easier.

❓ component_behavior

intermediate

What will this Express error middleware output when an error occurs?

Given this Express error middleware, what will the client receive if an error with message 'File not found' is passed?

Node.js

app.use((err, req, res, next) => {
  res.status(404).json({ error: err.message });
});

A {"error":"Internal Server Error"}

B {"message":"File not found"}

C {"error":"File not found"}

D 404 File not found (plain text)

💡 Hint

Look at the JSON key used in the response.

The middleware sends a JSON response with key 'error' and the error message. The status code is set to 404.

📝 Syntax

advanced

Identify the syntax error in this centralized error handler setup

Which option contains the correct syntax for an Express centralized error handler?

Node.js

app.use((err, req, res, next) => {
  res.status(500).send('Server error');
});

A app.use((err, req, res, next) => { res.status(500).send('Server error'); });

B app.use((err, req, res) => { res.status(500).send('Error'); });

C app.use((error, request, response, next) => { response.status(500).send('Error'); });

D app.use((err, req, res, next) => { res.status(500).send('Server error') });

💡 Hint

Check the number and order of parameters in the middleware function.

Express error middleware must have exactly four parameters: (err, req, res, next). Option A correctly follows this pattern.

🔧 Debug

advanced

Why does this centralized error handler not catch errors from async functions?

Consider this Express route and error handler. Why does the error handler not catch the thrown error?

Node.js

app.get('/data', async (req, res) => {
  throw new Error('Async failure');
});

app.use((err, req, res, next) => {
  res.status(500).json({ error: err.message });
});

A Because the error handler must be registered before the route.

B Because the error handler is missing the 'next' parameter.

C Because Express does not support error handling for GET routes.

D Because errors thrown inside async functions must be passed to next() explicitly or caught with a wrapper.

💡 Hint

Think about how Express handles errors in async functions.

Express does not automatically catch errors thrown in async functions. You must use try-catch or a wrapper to pass errors to next().

❓ state_output

expert

What is the output sequence when multiple errors are passed through next() in Express?

Given these middleware functions, what will be the final response sent to the client?

Node.js

app.use((req, res, next) => {
  next(new Error('First error'));
});

app.use((err, req, res, next) => {
  if (err.message === 'First error') {
    next(new Error('Second error'));
  } else {
    res.status(500).send(err.message);
  }
});

app.use((err, req, res, next) => {
  res.status(500).send(err.message);
});

A The client receives no response and the request hangs.

B The client receives 'Second error' with status 500.

C The client receives 'First error' with status 500.

D The client receives a 404 Not Found error.

💡 Hint

Follow the error passed through next() calls step by step.

The first middleware passes 'First error' to the error handler. The first error handler detects it and passes 'Second error' to the next error handler, which sends it as the response.