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

Challenge - 5 Problems

📝 Syntax

intermediate

Identify the correct error-handling middleware signature in Express

Which of the following function signatures correctly defines an error-handling middleware in Express?

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

B (req, res, next) => { /* handle error */ }

C (err, req, res) => { /* handle error */ }

D (req, res) => { /* handle error */ }

💡 Hint

Error-handling middleware in Express always has four parameters, starting with the error object.

Express error-handling middleware must have four parameters: err, req, res, and next. This signature tells Express to treat it as an error handler.

❓ component_behavior

intermediate

What happens when an error is passed to next() in Express?

In Express, if you call next(err) inside a middleware, what will Express do next?

A Restart the middleware stack from the beginning

B Continue to the next regular middleware ignoring the error

C Skip all remaining non-error middleware and call the next error-handling middleware

D Stop processing and send a default error response immediately

💡 Hint

Think about how Express knows to handle errors differently.

Calling next(err) tells Express to skip all normal middleware and jump to the next error-handling middleware (with four parameters).

🔧 Debug

advanced

Find the error in this Express error-handling middleware

What error will this middleware cause when an error occurs? function errorHandler(req, res, next) { res.status(500).send('Something broke!'); }

Express

function errorHandler(req, res, next) {
  res.status(500).send('Something broke!');
}

A It will not be recognized as error-handling middleware because it lacks the 'err' parameter

B It will cause a runtime error because 'next' is unused

C It will send a 404 status instead of 500

D It will cause a syntax error due to missing parentheses

💡 Hint

Error-handling middleware must have four parameters, starting with the error object.

Express identifies error-handling middleware by the presence of four parameters: err, req, res, next. This function only has three, so Express treats it as normal middleware and will not call it on errors.

❓ state_output

advanced

What is the response status code sent by this error-handling middleware?

Given this Express error-handling middleware, what status code will the client receive? function errorHandler(err, req, res, next) { if (err.status) { res.status(err.status).send(err.message); } else { res.status(500).send('Internal Server Error'); } }

Express

function errorHandler(err, req, res, next) {
  if (err.status) {
    res.status(err.status).send(err.message);
  } else {
    res.status(500).send('Internal Server Error');
  }
}

A Throws an error because res.status is called twice

B Always 200 regardless of error

C Always 404 regardless of error

D 500 if err.status is undefined, otherwise err.status

💡 Hint

Check how the status code is set depending on the error object.

The middleware checks if err.status exists. If yes, it uses that status code; otherwise, it defaults to 500.

🧠 Conceptual

expert

Why must error-handling middleware have four parameters in Express?

Why does Express require error-handling middleware to have exactly four parameters: (err, req, res, next)?

A Because JavaScript requires four parameters for error handling functions

B Because Express uses the function's parameter count to distinguish error handlers from regular middleware

C Because the 'next' parameter is mandatory for all middleware, including error handlers

D Because the 'err' parameter is optional and only used in some error handlers

💡 Hint

Think about how Express decides which middleware to call on errors.

Express checks the number of parameters in middleware functions. Functions with four parameters are treated as error handlers. This is how Express knows to call them when an error occurs.

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