Error-handling middleware signature in Express - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the special signature of an error-handling middleware function in Express?

An error-handling middleware function in Express has four parameters: (err, req, res, next). The first parameter err is the error object, followed by the usual request, response, and next function.

intermediate

Why does Express require error-handling middleware to have four parameters?

Express uses the number of parameters to identify error-handling middleware. If a middleware has four parameters, Express treats it as an error handler and calls it only when an error occurs.

beginner

Show a simple example of an Express error-handling middleware function.

Example:<br><pre>function errorHandler(err, req, res, next) {
  console.error(err.stack);
  res.status(500).send('Something broke!');
}</pre>

intermediate

What happens if you define an error-handling middleware with only three parameters in Express?

Express will not recognize it as an error handler and will treat it as a normal middleware. This means it won't be called automatically when an error occurs.

beginner

How do you pass an error to the error-handling middleware in Express?

You call next(err) inside a middleware or route handler, passing the error object. Express then skips normal middleware and calls the error-handling middleware.

What is the correct signature for an Express error-handling middleware?

A (req, res, next)

B (err, req, res, next)

C (req, res)

D (err, req, res)

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

How does Express know a middleware is for error handling?

A By a special flag in options

B By the middleware name

C By the order it is declared

D By the number of parameters (4)

Express checks if the middleware has four parameters to identify it as an error handler.

What happens if you call next() with an error inside a route handler?

A Express skips normal middleware and calls error-handling middleware

B Express ignores the error and continues

C Express crashes immediately

D Express sends a default error response automatically

Calling next(err) tells Express to skip normal middleware and call error handlers.

Which of these is NOT true about error-handling middleware in Express?

A It can be called without an error

B It can send a response to the client

C It is called only when an error occurs

D It must have four parameters

Error-handling middleware is called only when an error is passed to next().

If an error-handling middleware is missing, what happens when an error occurs?

A The error is ignored

B The app crashes

C Express sends a default error response

D The request hangs forever

Express has a default error handler that sends a generic error response if no custom handler is defined.

Explain the signature of an Express error-handling middleware and why it is important.

Think about how Express knows which middleware handles errors.

Describe how to trigger an error-handling middleware from a route or normal middleware in Express.

Focus on the role of the next function.

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