Error-handling middleware in Node.js - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

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

Node.js

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

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

Anext

Berror

Cresponse

Drequest

Attempts:

3 left

💡 Hint

Common Mistakes

Using only three parameters instead of four.

Naming the fourth parameter incorrectly.

The error-handling middleware in Express must have four parameters: err, req, res, and next. The next parameter is required to identify it as error-handling middleware.

2fill in blank

medium

Complete the code to send a JSON error response with status 400.

Node.js

app.use(function(err, req, res, next) {
  res.status([1]).json({ error: err.message });
});

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

A404

B200

C400

D500

Attempts:

3 left

💡 Hint

Common Mistakes

Using 200 which means success.

Using 500 which means server error instead of client error.

Status code 400 means a bad request error. Here, we want to send that status code when an error occurs.

3fill in blank

hard

Fix the error in the middleware signature to correctly handle errors.

Node.js

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

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

Aerror

Berr

Cnext

Drequest

Attempts:

3 left

💡 Hint

Common Mistakes

Placing the error parameter last instead of first.

Using wrong parameter names.

The error-handling middleware must have the error parameter as the first argument. The correct order is err, req, res, next. Here, the error parameter is misplaced and must be fixed.

4fill in blank

hard

Fill both blanks to correctly pass the error to the next middleware.

Node.js

app.use(function(err, req, res, [1]) {
  if (err) {
    [2](err);
  } else {
    next();
  }
});

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

Anext

Bres

Csend

Derror

Attempts:

3 left

💡 Hint

Common Mistakes

Calling res or send instead of next.

Using wrong parameter names.

The fourth parameter is next, which is a function to pass control to the next middleware. To forward the error, we call next(err).

5fill in blank

hard

Fill all three blanks to create a middleware that logs the error and sends a 500 response.

Node.js

app.use(function([1], [2], [3], next) {
  console.error([1].message);
  res.status(500).send('Internal Server Error');
});

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

Aerr

Breq

Cres

Dnext

Attempts:

3 left

💡 Hint

Common Mistakes

Mixing up the order of parameters.

Forgetting to log the error message.

The error-handling middleware parameters are err, req, res, and next. We log the error message from err and send a 500 response using res.

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