Centralized error handler in Express - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a centralized error handler in Express?

It is a single middleware function that catches and processes all errors in an Express app, so you don't have to handle errors in every route separately.

beginner

How do you define a centralized error handler middleware in Express?

You create a middleware function with four parameters: (err, req, res, next). Express recognizes it as an error handler and calls it when an error occurs.

intermediate

Why should you place the centralized error handler after all other middleware and routes?

Because Express calls middleware in order, placing the error handler last ensures it catches errors from all previous middleware and routes.

intermediate

What is the role of the 'next' function in an Express error handler?

It can be used to pass the error to the next error handler if you have multiple, or to continue the middleware chain if needed.

beginner

How can you send a user-friendly error message from a centralized error handler?

You can set the HTTP status code and send a JSON or text response with a simple message explaining the error without exposing sensitive details.

Which of these is the correct signature for an Express centralized error handler?

A (err, req, res, next)

B (req, res, next)

C (req, res)

D (err, req, res)

Express recognizes error handlers by having four parameters: err, req, res, and next.

Where should you place the centralized error handler middleware in your Express app?

A It doesn't matter

B Before all routes

C In the middle of routes

D After all routes and other middleware

The error handler should be last to catch errors from all previous middleware and routes.

What happens if you forget to call next() inside an error handler?

A The request will hang and not continue

B Nothing, it works fine

C Express will crash

D The error will be passed to the next middleware automatically

If next() is not called or response is not sent, the request will hang waiting for a response.

How can you send a 404 error using the centralized error handler?

A Use res.sendStatus(404) in routes only

B Call res.status(404).send() inside the error handler

C Throw an error with status 404 and pass it to next()

D You cannot handle 404 errors in centralized error handler

You create an error with status 404 and pass it to next(), so the centralized handler can respond.

What is a benefit of using a centralized error handler?

A It makes the app slower

B It reduces repeated error handling code in routes

C It hides all errors from developers

D It only works for syntax errors

Centralized error handling keeps your code clean by handling errors in one place.

Explain how to create and use a centralized error handler in an Express app.

Think about the special middleware signature and order.

Describe why centralized error handling improves Express app code quality.

Consider how handling errors in one place helps.

Practice

1. What is the main purpose of a centralized error handler in an Express app?

easy

A. To serve static files efficiently

B. To speed up the server response time

C. To catch and handle all errors in one place

D. To manage user sessions

Solution

1. Step 1: Understand error handling in Express

   Express allows middleware to catch errors and handle them centrally.

2. Step 2: Identify the role of centralized error handler

   It collects all errors from routes and middleware to respond consistently.

3. Final Answer:

   To catch and handle all errors in one place -> Option C

4. Quick Check:

   Centralized error handler = catch all errors [OK]

Hint: Centralized error handler catches errors globally, not locally [OK]

Common Mistakes:

• Thinking it improves server speed
• Confusing with static file serving
• Mixing with session management

2. Which of the following is the correct way to define a centralized error handler middleware in Express?

easy

A. app.use((req, res) => { res.status(500).send('Error'); });

B. app.use((err, req, res, next) => { res.status(500).send(err.message); });

C. app.get('/error', (err, req, res) => { res.send('Error'); });

D. app.use((req, res, next) => { res.send('Error'); });

Solution

1. Step 1: Recall Express error handler signature

   Error handlers have four parameters: (err, req, res, next).

2. Step 2: Match the correct middleware signature

   app.use((err, req, res, next) => { res.status(500).send(err.message); }); uses all four parameters correctly and sends error message.

3. Final Answer:

   app.use((err, req, res, next) => { res.status(500).send(err.message); }); -> Option B

4. Quick Check:

   Error handler middleware needs 4 params [OK]

Hint: Error handler middleware always has 4 parameters (err, req, res, next) [OK]

Common Mistakes:

• Using only 3 parameters in error handler
• Defining error handler as route handler
• Missing the 'err' parameter

3. Given this Express code snippet, what will be the response if an error occurs in the route?

app.get('/test', (req, res, next) => {
  next(new Error('Oops!'));
});

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

medium

A. Status 500 with body 'Error caught: Oops!'

B. Status 200 with body 'Oops!'

C. Status 404 with body 'Not Found'

D. No response, server crashes

Solution

1. Step 1: Understand error propagation in route

   The route calls next() with an Error object, triggering error middleware.

2. Step 2: Check error handler response

   The error handler sends status 500 and message including error text.

3. Final Answer:

   Status 500 with body 'Error caught: Oops!' -> Option A

4. Quick Check:

   Error passed to handler = 500 response with message [OK]

Hint: next(error) triggers centralized error handler with status 500 [OK]

Common Mistakes:

• Expecting status 200 instead of 500
• Thinking error handler is skipped
• Assuming server crashes on error

4. Identify the error in this Express app setup for centralized error handling:

app.use((req, res, next) => {
  throw new Error('Fail');
});

app.use((req, res, next) => {
  res.status(500).send('Error occurred');
});

medium

A. Error handler middleware missing 'err' parameter

B. Throwing error inside middleware is not allowed

C. Error handler middleware should be placed before routes

D. Middleware order is correct, no error

Solution

1. Step 1: Check error handler signature

   Error handlers must have 4 parameters: (err, req, res, next).

2. Step 2: Analyze given error handler

   The second middleware has only (req, res, next), so it won't catch errors.

3. Final Answer:

   Error handler middleware missing 'err' parameter -> Option A

4. Quick Check:

   Error handler needs 4 params to catch errors [OK]

Hint: Error handler must have 4 parameters to work [OK]

Common Mistakes:

• Forgetting the 'err' parameter in error handler
• Placing error handler before routes
• Thinking throwing error is disallowed

5. You want to create a centralized error handler that logs errors and sends a JSON response with status code and message. Which code snippet correctly implements this?

hard

A. app.use((req, res, next) => { console.error('Error'); res.json({ error: 'Unknown' }); });

B. app.use((err, req, res, next) => { res.send('Error occurred'); });

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

D. app.use((err, req, res, next) => { console.error(err); res.status(err.status || 500).json({ error: err.message }); });

Solution

1. Step 1: Confirm error handler signature and logging

   app.use((err, req, res, next) => { console.error(err); res.status(err.status || 500).json({ error: err.message }); }); uses (err, req, res, next) and logs error with console.error.

2. Step 2: Check response format and status code

   app.use((err, req, res, next) => { console.error(err); res.status(err.status || 500).json({ error: err.message }); }); sends JSON with error message and status code from error or 500.

3. Final Answer:

   app.use((err, req, res, next) => { console.error(err); res.status(err.status || 500).json({ error: err.message }); }); -> Option D

4. Quick Check:

   Proper error handler logs and sends JSON with status [OK]

Hint: Error handler needs 4 params, logs error, sends JSON with status [OK]

Common Mistakes:

• Missing 'next' parameter in error handler
• Not logging the error
• Sending plain text instead of JSON