Error-handling middleware signature in Express - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define an error-handling middleware function in Express.

Express

app.use(function(err, req, res, [1]) {
  res.status(500).send('Something broke!');
});

Drag options to blanks, or click blank then click option'

Arequest

Bres

Cerror

Dnext

Attempts:

3 left

💡 Hint

Common Mistakes

Using only three parameters instead of four.

Naming the last parameter incorrectly.

Omitting the next parameter.

The error-handling middleware in Express must have four parameters: err, req, res, and next. The next parameter is required even if unused.

2fill in blank

medium

Complete the code to correctly call the next middleware in an error handler.

Express

app.use(function(err, req, res, next) {
  if (!err) return [1]();
  res.status(500).send('Error occurred');
});

Drag options to blanks, or click blank then click option'

Ares

Bnext

Cerr

Dreq

Attempts:

3 left

💡 Hint

Common Mistakes

Calling res() instead of next().

Forgetting to call next().

Passing the error to next when no error exists.

In Express, calling next() passes control to the next middleware. Here, if there is no error, we call next() to continue.

3fill in blank

hard

Fix the error in the middleware signature to make it a valid error handler.

Express

app.use(function([1], req, res, next) {
  res.status(500).send('Oops!');
});

Drag options to blanks, or click blank then click option'

Aerr

Brequest

Cnext

Derror

Attempts:

3 left

💡 Hint

Common Mistakes

Placing err last instead of first.

Using only three parameters.

Misnaming parameters.

Error-handling middleware must have four parameters in this order: err, req, res, next. The code had the wrong order and missing err as first parameter.

4fill in blank

hard

Fill both blanks to create a middleware that logs errors and passes them on.

Express

app.use(function([1], req, res, [2]) {
  console.error([1]);
  [2]([1]);
});

Drag options to blanks, or click blank then click option'

Aerr

Bnext

Cres

Dreq

Attempts:

3 left

💡 Hint

Common Mistakes

Using res or req instead of err or next.

Not calling next(err) to pass the error.

The error object is err and the function to pass control is next. The middleware logs the error and calls next(err) to continue error handling.

5fill in blank

hard

Fill all three blanks to send a JSON error response with status 500.

Express

app.use(function([1], req, [2], [3]) {
  [2].status(500).json({ error: [1].message });
});

Drag options to blanks, or click blank then click option'

Aerr

Bres

Cnext

Dreq

Attempts:

3 left

💡 Hint

Common Mistakes

Mixing up req and res parameters.

Omitting the next parameter.

Not sending a JSON response.

The error object is err, the response object is res, and next is the last parameter. The middleware sends a JSON response with the error message and status 500.

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