Error-handling middleware signature in Express

Introduction

Error-handling middleware helps catch and respond to errors in your app. It keeps your app from crashing and shows helpful messages.

When you want to catch errors from routes or other middleware

When you want to send a friendly error message to users

When you want to log errors for debugging

When you want to handle different error types differently

When you want to keep your app running smoothly even if something goes wrong

Syntax

Express

function errorHandler(err, req, res, next) {
  // handle the error
}

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

Express knows it is error-handling middleware because of the four parameters.

Examples

Basic error handler that sends a 500 status and a simple message.

Express

app.use(function (err, req, res, next) {
  res.status(500).send('Something broke!')
})

Logs the error stack to the console and sends a JSON response with the error message.

Express

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

Sample Program

This app throws an error on the home route. The error-handling middleware catches it, logs the message, and sends a 500 response.

Express

import express from 'express'
const app = express()

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

app.use((err, req, res, next) => {
  console.error('Error caught:', err.message)
  res.status(500).send('Internal Server Error')
})

app.listen(3000, () => {
  console.log('Server running on http://localhost:3000')
})

Important Notes

Always place error-handling middleware after all other middleware and routes.

Calling next() inside error middleware passes the error to the next error handler.

Summary

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

It catches errors and prevents app crashes.

Use it to send user-friendly error messages and log problems.

Practice

1. Which of the following correctly describes the signature of an error-handling middleware function in Express?

easy

A. It has five parameters: err, req, res, next, done.

B. It has three parameters: req, res, next.

C. It has two parameters: req, res.

D. It has four parameters: err, req, res, next.

Solution

1. Step 1: Recall Express middleware function signatures

   Normal middleware functions have three parameters: req, res, next. Error-handling middleware must have four parameters.

2. Step 2: Identify the error-handling middleware signature

   Error-handling middleware functions always start with err as the first parameter, followed by req, res, next.

3. Final Answer:

   It has four parameters: err, req, res, next. -> Option D

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 for error middleware
• Forgetting the err parameter at the start
• Adding extra parameters beyond four

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

easy

A. app.use(function(req, res, next, err) { /* code */ });

B. app.use(function(err, req, res, next) { /* code */ });

C. app.use(function(err, req, next, res) { /* code */ });

D. app.use(function(req, err, res, next) { /* code */ });

Solution

1. Step 1: Check parameter order in error middleware

   The correct order is err, req, res, next. This order is required by Express to recognize error middleware.

2. Step 2: Match the correct syntax

   app.use(function(err, req, res, next) { /* code */ }); matches the correct order and syntax for error-handling middleware.

3. Final Answer:

   app.use(function(err, req, res, next) { /* code */ }); -> Option B

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:

• Placing err parameter last or in the wrong position
• Swapping req and res parameters
• Using incorrect function parameter count

3. What will happen when this Express error-handling middleware is added?

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

medium

A. It catches errors and sends a 500 status with the error message.

B. It ignores errors and passes them to the next middleware.

C. It causes a syntax error because of missing next() call.

D. It crashes the app because error middleware must call next().

Solution

1. Step 1: Understand error middleware behavior

   Error-handling middleware catches errors passed by previous middleware or routes.

2. Step 2: Analyze the middleware code

   This middleware sends a 500 status and the error message as a response, handling the error gracefully.

3. Final Answer:

   It catches errors and sends a 500 status with the error message. -> Option A

4. Quick Check:

   Error middleware sends 500 and message = It catches errors and sends a 500 status with the error message. [OK]

Hint: Error middleware sends response with status 500 and error message [OK]

Common Mistakes:

• Thinking next() must always be called in error middleware
• Assuming error middleware crashes app without next()
• Confusing error middleware with normal middleware

4. Identify the error in this Express error-handling middleware:

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

medium

A. Error middleware cannot use console.error().

B. Missing call to next() inside the middleware.

C. The parameters are in the wrong order; err must be first.

D. res.status(500) is invalid inside error middleware.

Solution

1. Step 1: Check parameter order for error middleware

   Error-handling middleware must have parameters in order: err, req, res, next. Here, err is last, which is incorrect.

2. Step 2: Understand impact of wrong parameter order

   Express will not recognize this as error middleware, so errors won't be caught properly.

3. Final Answer:

   The parameters are in the wrong order; err must be first. -> Option C

4. Quick Check:

   err parameter must be first in error middleware [OK]

Hint: Error middleware must start with err parameter [OK]

Common Mistakes:

• Placing err parameter anywhere but first
• Assuming next() call is mandatory in all error middleware
• Confusing error middleware with normal middleware signature

5. You want to create an error-handling middleware that logs the error and sends a JSON response with status 500. Which of the following is the best correct implementation?

hard

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

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

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

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

Solution

1. Step 1: Verify parameter count and order

   Error middleware must have exactly four parameters in order: err, req, res, next. app.use((err, req, res, next) => { console.log(err); res.status(500).json({error: err.message}); }); matches this.

2. Step 2: Check response status and format

   app.use((err, req, res, next) => { console.log(err); res.status(500).json({error: err.message}); }); sets status 500 and sends JSON with error message, which is correct and user-friendly.

3. Final Answer:

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

4. Quick Check:

   Correct signature + status 500 + JSON response = app.use((err, req, res, next) => { console.log(err); res.status(500).json({error: err.message}); }); [OK]

Hint: Error middleware needs 4 params and sets status before sending JSON [OK]

Common Mistakes:

• Wrong parameter order or count
• Forgetting to set status code
• Sending response without JSON format