Error-handling middleware in Express - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

How does error-handling middleware behave in Express?

Consider an Express app with a route that throws an error. What happens when an error-handling middleware is defined with four parameters?

Which statement best describes the behavior?

A The error-handling middleware runs for every request, regardless of errors.

B The error-handling middleware only handles errors if they are thrown asynchronously inside setTimeout.

C The error-handling middleware catches errors passed with next(err) or thrown synchronously and handles them.

D The error-handling middleware must be the first middleware to catch errors.

💡 Hint

Error-handling middleware in Express has a special signature with four parameters.

In Express, error-handling middleware is defined with four parameters: (err, req, res, next). It catches errors passed to next(err) or thrown synchronously in routes or middleware. It does not run for every request, only when an error occurs.

📝 Syntax

intermediate

Identify the correct error-handling middleware syntax in Express

Which of the following middleware functions is correctly defined as an error-handling middleware in Express?

A function (req, res) { res.status(500).send('Error occurred'); }

B function (err, req, res, next) { res.status(500).send('Error occurred'); }

C function (req, res, next) { res.status(500).send('Error occurred'); }

D function (err, req, res) { res.status(500).send('Error occurred'); }

💡 Hint

Error-handling middleware must have four parameters.

Error-handling middleware in Express must have exactly four parameters: (err, req, res, next). This signature tells Express to treat it as error-handling middleware.

🔧 Debug

advanced

Why does this error-handling middleware not catch errors?

Given this Express app code:

app.get('/test', (req, res) => { throw new Error('fail'); });
app.use((req, res, next) => { res.status(404).send('Not found'); });
app.use((err, req, res, next) => { res.status(500).send('Server error'); });

Why does the error-handling middleware not catch the thrown error?

A Because the 404 middleware is placed before the error-handling middleware and does not call next(err).

B Because the error-handling middleware must be defined before any routes.

C Because the thrown error is asynchronous and not caught by Express.

D Because the error-handling middleware is missing the next parameter.

💡 Hint

Middleware order matters in Express.

The 404 middleware catches all requests not handled by previous routes but does not pass errors to next(err). Since it is placed before the error-handling middleware and does not forward errors, the error-handling middleware never runs.

❓ state_output

advanced

What is the response status code when an error is passed to next()?

In this Express app snippet:

app.get('/fail', (req, res, next) => { next(new Error('fail')); });
app.use((err, req, res, next) => { res.status(400).send('Bad request'); });

What status code will the client receive when requesting /fail?

A 404

B 500

C 200

D 400

💡 Hint

The error-handling middleware sets the status code explicitly.

The error-handling middleware sets the response status to 400 before sending the response. So the client receives status 400.

🧠 Conceptual

expert

Which statement about error-handling middleware chaining is true?

In Express, if multiple error-handling middleware are defined, how does Express decide which one to run?

A Express runs error-handling middleware in the order they are defined until one sends a response or calls next().

B Express runs only the first error-handling middleware and ignores the rest.

C Express runs all error-handling middleware in parallel.

D Express randomly picks one error-handling middleware to run.

💡 Hint

Think about how middleware chaining works in Express.

Express runs error-handling middleware in the order they are defined. Each can handle the error or pass it on by calling next(err). This allows chaining multiple error handlers.

Practice

1. What is the main purpose of error-handling middleware in Express?

easy

A. To serve static files like images and CSS

B. To parse incoming JSON request bodies

C. To catch errors and prevent the server from crashing

D. To log every request made to the server

Solution

1. Step 1: Understand middleware roles

   Middleware can serve many roles, but error-handling middleware specifically catches errors.

2. Step 2: Identify error-handling middleware purpose

   Error-handling middleware prevents the server from crashing by catching errors and responding properly.

3. Final Answer:

   To catch errors and prevent the server from crashing -> Option C

4. Quick Check:

   Error-handling middleware = catch errors [OK]

Hint: Error middleware catches errors to keep server running [OK]

Common Mistakes:

• Confusing error middleware with static file serving
• Thinking it parses request bodies
• Assuming it logs requests

2. Which of the following is the correct signature for an Express error-handling middleware function?

easy

A. (err, req, res, next)

B. (req, res, next)

C. (req, res)

D. (err, res, next)

Solution

1. Step 1: Recall error middleware parameters

   Error-handling middleware always has four parameters: err, req, res, next.

2. Step 2: Match the correct parameter order

   Only (err, req, res, next) has all four parameters in the correct order.

3. Final Answer:

   (err, req, res, next) -> Option A

4. Quick Check:

   Error middleware signature = (err, req, res, next) [OK]

Hint: Error middleware always has 4 parameters starting with err [OK]

Common Mistakes:

• Using only three parameters
• Omitting the err parameter
• Wrong parameter order

3. Given the code below, what will be the response if an error occurs in the route?

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

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

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

app.listen(3000);

medium

A. The client receives 'Error caught: Oops!' with status 500

B. The server crashes and stops running

C. The client receives a 404 Not Found error

D. The client receives an empty response with status 200

Solution

1. Step 1: Identify error thrown in route

   The route throws an error with message 'Oops!'.

2. Step 2: Check error-handling middleware response

   The error middleware catches the error and sends a 500 status with message including 'Oops!'.

3. Final Answer:

   The client receives 'Error caught: Oops!' with status 500 -> Option A

4. Quick Check:

   Error thrown = caught and sent with 500 [OK]

Hint: Thrown errors go to error middleware response [OK]

Common Mistakes:

• Expecting server crash on error
• Confusing 404 with error response
• Missing error message in response

4. What is wrong with the following error-handling middleware?

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

medium

A. It should be placed before routes

B. The parameters are in the wrong order

C. It is missing the next() call

D. It should not have four parameters

Solution

1. Step 1: Check parameter order for error middleware

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

2. Step 2: Identify incorrect order in code

   The code has (req, res, next, err) which is incorrect.

3. Final Answer:

   The parameters are in the wrong order -> Option B

4. Quick Check:

   Error middleware params order = err, req, res, next [OK]

Hint: Error middleware params start with err, not req [OK]

Common Mistakes:

• Swapping err and req parameters
• Placing error middleware before routes
• Forgetting to call next() when needed

5. You want to create an error-handling middleware that logs the error message and then passes the error to the next middleware. Which of the following implementations is correct?

A) app.use((err, req, res, next) => {
  console.log(err.message);
  next(err);
});

B) app.use((req, res, next, err) => {
  console.log(err.message);
  next();
});

C) app.use((err, req, res) => {
  console.log(err.message);
  next(err);
});

D) app.use((err, req, res, next) => {
  console.log(err.message);
  res.send('Error logged');
});

hard

A. app.use((err, req, res, next) => {
console.log(err.message);
res.send('Error logged');
});

B. app.use((req, res, next, err) => {
console.log(err.message);
next();
});

C. app.use((err, req, res) => {
console.log(err.message);
next(err);
});

D. app.use((err, req, res, next) => {
console.log(err.message);
next(err);
});

Solution

1. Step 1: Recall requirements for error-handling middleware that chains

   It must have four parameters starting with err, log err.message, and call next(err) to pass the error to the next handler.

2. Step 2: Match against provided implementations

   Implementations with incorrect parameter order or count fail to receive or handle err properly; those that respond instead of calling next(err) break the chain.

3. Final Answer:

   app.use((err, req, res, next) => {
     console.log(err.message);
     next(err);
   }); -> Option D

4. Quick Check:

   4 params + next(err) = correct chaining [OK]

Hint: Error middleware must have 4 params and call next(err) to continue [OK]

Common Mistakes:

• Wrong parameter order
• Forgetting next parameter
• Not calling next(err) to pass error along
• Sending response too early