Error-handling middleware in Node.js - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

How does error-handling middleware affect request flow in Express?

Consider an Express app with normal middleware and error-handling middleware. What happens when an error is passed to next()?

Node.js

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

app.use((req, res, next) => {
  if (req.query.fail) {
    next(new Error('Failure triggered'));
  } else {
    next();
  }
});

app.use((req, res, next) => {
  res.send('Success');
});

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

A The error-handling middleware runs only if <code>res.send()</code> is not called first.

B The error is ignored and the normal middleware continues to run, sending 'Success'.

C The app crashes immediately when <code>next()</code> is called with an error.

D If <code>next()</code> is called with an error, the error-handling middleware runs and sends a 500 response.

💡 Hint

Think about how Express decides which middleware to run when next() receives an error.

When next() is called with an error, Express skips normal middleware and runs error-handling middleware. This middleware has four arguments (err, req, res, next) and handles the error, often sending a 500 response.

📝 Syntax

intermediate

Identify the syntax error in this error-handling middleware

Which option contains a syntax error in defining error-handling middleware in Express?

Node.js

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

A Missing <code>next</code> parameter in the middleware function signature.

B Using <code>function</code> keyword instead of arrow function.

C Middleware function has four parameters but <code>err</code> is not first.

D Calling <code>res.status()</code> without <code>send()</code>.

💡 Hint

Error-handling middleware must have exactly four parameters.

Error-handling middleware in Express must have four parameters: err, req, res, next. Missing the next parameter causes Express to treat it as normal middleware, so it won't catch errors properly.

🔧 Debug

advanced

Why does this error-handling middleware never run?

Given this Express app, why does the error-handling middleware never respond?

Node.js

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

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

app.use((req, res, next) => {
  res.send('Hello');
});

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

A The error-handling middleware is missing the <code>next</code> parameter.

B The error-handling middleware has parameters in the wrong order; <code>err</code> must be first.

C The error-handling middleware is placed before the normal middleware.

D The error-handling middleware uses arrow function syntax which is not supported.

💡 Hint

Check the order of parameters in error-handling middleware.

Error-handling middleware must have four parameters in this order: err, req, res, next. The code has req, res, next, err, so Express does not recognize it as error-handling middleware and never calls it.

❓ state_output

advanced

What is the response status and body when an error is thrown inside async middleware?

Consider this Express async middleware that throws an error. What response does the client receive?

Node.js

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

app.use(async (req, res, next) => {
  throw new Error('Async failure');
});

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

A The app crashes with an unhandled promise rejection error.

B The client receives a 500 status with body 'Caught: Async failure'.

C The client receives no response and the request times out.

D The client receives a 200 status with empty body.

💡 Hint

Think about how Express handles errors thrown inside async functions.

Express does not automatically catch errors thrown inside async middleware unless next(err) is called or the async function is wrapped. Throwing an error inside async middleware causes an unhandled promise rejection and crashes the app.

🧠 Conceptual

expert

Which statement about error-handling middleware in Express is TRUE?

Choose the correct statement about error-handling middleware behavior in Express.

A Calling <code>next()</code> without arguments inside error-handling middleware passes control to the next error handler.

B Error-handling middleware must be the last middleware added to the app to catch all errors.

C Error-handling middleware is identified by having exactly four parameters: <code>err, req, res, next</code>.

D If an error occurs in normal middleware, Express automatically skips all remaining middleware and sends a 500 response.

💡 Hint

Recall how Express detects error-handling middleware.

Express identifies error-handling middleware by the function signature having four parameters: err, req, res, next. This is how it knows to call it when an error occurs. Other statements are false: error handlers do not have to be last, next() without arguments inside error handlers passes control to normal middleware, and Express does not automatically send 500 responses without error handlers.

Practice

1. What is the correct number of parameters for an error-handling middleware function in Node.js Express?

easy

A. One parameter: err

B. Three parameters: req, res, next

C. Two parameters: req, res

D. Four parameters: err, req, res, next

Solution

1. Step 1: Recall the error middleware signature

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

2. Step 2: Understand the role of each parameter

   The first parameter is the error object, followed by the request, response, and next function to pass control.

3. Final Answer:

   Four parameters: err, req, res, next -> Option D

4. Quick Check:

   Error middleware = 4 parameters [OK]

Hint: Error middleware always has 4 parameters: err, req, res, next [OK]

Common Mistakes:

• Using 3 parameters like normal middleware
• Forgetting the err parameter
• Placing error middleware before routes

2. Which of the following is the correct syntax to define an error-handling middleware in Express?

easy

A. app.use((err, req, res, next) => { /* handle error */ })

B. app.use((req, res, next, err) => { /* handle error */ })

C. app.use((err, req, next, res) => { /* handle error */ })

D. app.use((req, err, res, next) => { /* handle error */ })

Solution

1. Step 1: Check parameter order in error middleware

   The correct order is err, req, res, next for error-handling middleware.

2. Step 2: Verify the syntax matches Express pattern

   app.use((err, req, res, next) => { /* handle error */ }) matches the correct order and syntax for error middleware.

3. Final Answer:

   app.use((err, req, res, next) => { /* handle error */ }) -> Option A

4. Quick Check:

   Correct parameter order = err, req, res, next [OK]

Hint: Error middleware params start with err, then req, res, next [OK]

Common Mistakes:

• Mixing parameter order
• Placing err parameter last or in the middle
• Using normal middleware syntax for error middleware

3. Consider this Express app code snippet:

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

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

What will the client receive when requesting /test?

medium

A. A 404 Not Found error

B. A 500 status with 'Error caught' message

C. A 200 status with no response body

D. The server crashes with an uncaught exception

Solution

1. Step 1: Understand error thrown in route handler

   The route throws an error which Express catches and passes to error middleware.

2. Step 2: Error middleware sends 500 status and message

   The error middleware sets status 500 and sends 'Error caught' to the client.

3. Final Answer:

   A 500 status with 'Error caught' message -> Option B

4. Quick Check:

   Error thrown -> error middleware response [OK]

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

Common Mistakes:

• Expecting 200 OK despite error
• Thinking server crashes without middleware
• Confusing 404 with error middleware response

4. What is wrong with this error-handling middleware code?

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

medium

A. It should have only two parameters

B. It should be placed before routes

C. It is missing the next parameter

D. It should not use res.status

Solution

1. Step 1: Check error middleware parameters

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

2. Step 2: Identify missing parameter

   The code is missing the next parameter, which is required even if unused.

3. Final Answer:

   It is missing the next parameter -> Option C

4. Quick Check:

   Error middleware needs 4 params including next [OK]

Hint: Error middleware always needs 4 parameters, including next [OK]

Common Mistakes:

• Omitting next parameter
• Placing error middleware before routes
• Using wrong parameter order

5. You want to log errors and then send a response in your Express app. Which is the best way to write the error-handling middleware?

app.use((err, req, res, next) => {
  console.error(err.stack);
  res.status(500).send('Something broke!');
});

What is a potential problem with this code if you add more error middleware after it?

hard

A. It does not call next(), so later error middleware won't run

B. It calls next() without an error, causing infinite loop

C. It sends response twice causing an error

D. It should not log errors in middleware

Solution

1. Step 1: Analyze middleware flow after sending response

   Once res.send is called, response is sent and middleware usually ends.

2. Step 2: Understand next() usage in error middleware

   If next() is not called, any following error middleware won't execute.

3. Step 3: Identify problem if more error middleware exists

   Without calling next(err), later error middleware is skipped, possibly missing logging or handling.

4. Final Answer:

   It does not call next(), so later error middleware won't run -> Option A

5. Quick Check:

   Missing next() call skips later error middleware [OK]

Hint: Call next(err) to continue error middleware chain [OK]

Common Mistakes:

• Not calling next() after sending response
• Calling next() without error causing loops
• Logging errors outside middleware