Why error handling is critical in Express - Test Your Understanding

Practice - 5 Tasks

1fill in blank

easy

Complete the code to add a basic error handler middleware in Express.

Express

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

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

Ares

Bresponse

Cerror

Dnext

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'next' instead of 'res' as the third parameter.

Omitting the error parameter 'err'.

The error handler middleware in Express must have four parameters: err, req, res, and next. Here, res is the response object used to send the error message.

2fill in blank

medium

Complete the code to catch errors in an async route handler using Express.

Express

app.get('/data', async (req, res, [1]) => {
  try {
    const data = await fetchData();
    res.json(data);
  } catch (err) {
    next(err);
  }
});

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

Aresponse

Berror

Cres

Dnext

Attempts:

3 left

💡 Hint

Common Mistakes

Forgetting to include 'next' as a parameter.

Trying to handle errors without calling 'next(err)'.

The next function is used to pass errors to Express's error handler. It must be included as the third parameter in the route handler.

3fill in blank

hard

Fix the error in the middleware to properly handle errors in Express.

Express

function errorHandler(err, req, res, [1]) {
  res.status(500).json({ message: err.message });
}

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

Anext

Berror

Cresponse

Dres

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'res' or 'response' instead of 'next' as the fourth parameter.

Omitting the fourth parameter entirely.

The fourth parameter in an Express error handler middleware must be next to properly handle the error flow.

4fill in blank

hard

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

Express

function logErrors(err, [1], [2], next) {
  console.error(err.stack);
  next(err);
}

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

Areq

Bres

Crequest

Dresponse

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'request' and 'response' instead of 'req' and 'res'.

Swapping the order of parameters.

The error logging middleware receives err, req, res, and next as parameters. Here, req and res represent the request and response objects.

5fill in blank

hard

Fill all three blanks to create a custom error class and use it in Express.

Express

class [1] extends Error {
  constructor(message) {
    super(message);
    this.status = [2];
  }
}

app.use((err, req, res, next) => {
  if (err instanceof [3]) {
    res.status(err.status).send(err.message);
  } else {
    next(err);
  }
});

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

AHttpError

B404

DCustomError

Attempts:

3 left

💡 Hint

Common Mistakes

Using different names for the class and instance check.

Setting status as a string instead of a number.

This code defines a custom error class named CustomError that extends the built-in Error. It sets a status property, here 404. The middleware checks if the error is an instance of CustomError to handle it properly.

Practice

1. Why is error handling important in an Express app?

easy

A. It automatically fixes bugs in the code.

B. It makes the app run faster by skipping checks.

C. It prevents the app from crashing and shows friendly messages to users.

D. It hides all errors so developers don't see them.

Solution

1. Step 1: Understand the role of error handling

   Error handling helps catch problems before they crash the app and allows showing helpful messages.

2. Step 2: Compare options with this role

   Only It prevents the app from crashing and shows friendly messages to users. describes preventing crashes and user-friendly messages, which is the main goal.

3. Final Answer:

   It prevents the app from crashing and shows friendly messages to users. -> Option C

4. Quick Check:

   Error handling = prevent crashes + friendly messages [OK]

Hint: Error handling stops crashes and helps users understand issues [OK]

Common Mistakes:

• Thinking error handling speeds up the app
• Believing error handling fixes bugs automatically
• Assuming error handling hides errors from developers

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

easy

A. function (err, req, res, next) { /* handle error */ }

B. function (req, res, next) { /* handle error */ }

C. function (req, res) { /* handle error */ }

D. function (err, req, res) { /* handle error */ }

Solution

1. Step 1: Recall Express error middleware signature

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

2. Step 2: Match options to this signature

   Only function (err, req, res, next) { /* handle error */ } has all four parameters in correct order.

3. Final Answer:

   function (err, req, res, next) { /* handle error */ } -> Option A

4. Quick Check:

   Error middleware = 4 params (err, req, res, next) [OK]

Hint: Error middleware always has 4 parameters, starting with err [OK]

Common Mistakes:

• Using 3 parameters for error middleware
• Omitting the err parameter
• Mixing parameter order

3. Consider this Express code snippet:

app.get('/data', (req, res, next) => {
  try {
    throw new Error('Failed to load');
  } catch (err) {
    next(err);
  }
});

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

What will the user see when they visit /data?

medium

A. Internal Server Error

B. Error: Failed to load

C. No response, request hangs

D. SyntaxError

Solution

1. Step 1: Analyze the route handler

   The route throws an error and passes it to next(err), triggering error middleware.

2. Step 2: Check the error middleware response

   The error middleware sends status 500 with message 'Error: ' plus the error message.

3. Final Answer:

   Error: Failed to load -> Option B

4. Quick Check:

   Error passed to middleware shows message [OK]

Hint: Errors passed to next() show in error middleware response [OK]

Common Mistakes:

• Expecting default 500 message instead of custom
• Thinking request hangs without response
• Confusing error types

4. What is wrong with this Express error handler?

app.use((err, req, res) => {
  res.status(500).send('Oops!');
});

medium

A. It is missing the next parameter, so Express won't recognize it as error middleware.

B. It should not send a response inside error middleware.

C. It should use res.json() instead of res.send().

D. It should be placed before all route handlers.

Solution

1. Step 1: Check error middleware signature

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

2. Step 2: Identify missing parameter

   The handler has only three parameters, missing next, so Express treats it as normal middleware.

3. Final Answer:

   It is missing the next parameter, so Express won't recognize it as error middleware. -> Option A

4. Quick Check:

   Error middleware needs 4 params including next [OK]

Hint: Error middleware must have 4 parameters, including next [OK]

Common Mistakes:

• Omitting the next parameter
• Placing error middleware before routes
• Confusing res.send() with res.json()

5. You want to log errors and send a friendly message without exposing details. Which Express error middleware correctly does this?

app.use((err, req, res, next) => {
  console.error(err.stack);
  res.status(500).send('Something went wrong, please try again later.');
});

hard

A. This middleware should call next() after sending response.

B. This middleware exposes error details to users, which is unsafe.

C. This middleware does not log errors properly.

D. This middleware logs the error stack and sends a safe message to users.

Solution

1. Step 1: Check error logging

   The middleware logs the full error stack to the console for developers.

2. Step 2: Check user response

   It sends a generic message without revealing error details, protecting users.

3. Final Answer:

   This middleware logs the error stack and sends a safe message to users. -> Option D

4. Quick Check:

   Log errors, send friendly message = safe error handling [OK]

Hint: Log error details internally, show generic message externally [OK]

Common Mistakes:

• Sending error stack to users
• Not logging errors at all
• Calling next() after response sent