Centralized error handler in Express - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output when an error is thrown in this Express route?

Consider this Express app snippet with a centralized error handler. What will the client receive if the route throws an error?

Express

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

app.get('/test', (req, res, next) => {
  throw new Error('Oops!');
});

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

A Empty response with status 200

B Server crashes with unhandled exception

C {"error":"Internal Server Error"} with status 500

D {"message":"Oops!"} with status 500

💡 Hint

Think about how Express handles errors thrown inside routes and the role of the error middleware.

When an error is thrown inside a route, Express passes it to the error-handling middleware. Here, the middleware sends a JSON response with the error message and status 500.

📝 Syntax

intermediate

Which option correctly defines an Express error-handling middleware?

Select the option that correctly defines a centralized error handler middleware in Express.

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

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

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

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

💡 Hint

Error middleware must have four parameters: err, req, res, next.

Express recognizes error-handling middleware by the presence of four parameters. Option A correctly uses (err, req, res, next).

🔧 Debug

advanced

Why does this centralized error handler not catch errors thrown in async route handlers?

Given this code, errors thrown inside the async route are not caught by the error handler. Why?

Express

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

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

A Because the error handler is defined after the route, so it is ignored.

B Because Express does not support async functions in routes.

C Because errors in async functions must be passed to next(err) explicitly or caught with try/catch.

D Because the error handler middleware is missing the 'next' parameter.

💡 Hint

Think about how errors in async functions behave in Express.

Errors thrown inside async route handlers are not automatically caught by Express. They must be passed to next(err) or handled with try/catch to reach the error middleware.

❓ state_output

advanced

What is the response status and body when next() is called with an error?

In this Express app, what response does the client get when next(new Error('Fail')) is called inside a route?

Express

app.get('/fail', (req, res, next) => {
  next(new Error('Fail'));
});

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

A Status 500 with JSON {"message":"Fail"}

B Status 400 with JSON {"message":"Fail"}

C Status 200 with empty body

D No response, request hangs

💡 Hint

Check how the error handler sets the status code and response body.

The error handler sets status 400 and sends the error message as JSON, so the client receives status 400 with the message.

🧠 Conceptual

expert

Why should centralized error handlers be placed after all routes in Express?

Select the best explanation for why centralized error-handling middleware must be registered after all route handlers.

A Because Express executes middleware in order, so error handlers must come last to catch errors from previous routes.

B Because error handlers only work if placed before routes to intercept errors early.

C Because placing error handlers before routes causes syntax errors.

D Because error handlers automatically run in parallel with routes regardless of order.

💡 Hint

Think about the flow of request handling in Express.

Express processes middleware and routes in the order they are added. Error handlers must be last to catch errors from all previous middleware and routes.