Synchronous error handling in Express - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Express middleware error handling?

Consider this Express middleware function. What will the server respond with when a synchronous error occurs?

Express

const express = require('express');
const app = express();

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

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

app.listen(3000);

A The server responds with status 500 and body 'Error caught: Synchronous error'.

B The server crashes and stops running.

C The server responds with status 200 and an empty body.

D The server responds with status 404 Not Found.

💡 Hint

Think about how Express handles errors thrown inside middleware.

Express catches synchronous errors thrown in middleware and passes them to error-handling middleware, which sends the response with status 500 and the error message.

❓ Predict Output

intermediate

What happens if next() is called with an error synchronously?

Look at this Express route handler. What will the server respond with when the route is accessed?

Express

const express = require('express');
const app = express();

app.get('/', (req, res, next) => {
  next(new Error('Error passed to next'));
});

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

app.listen(3000);

A The server responds with status 200 and body 'OK'.

B The server responds with status 404 Not Found.

C The server responds with status 500 and body 'Caught error: Error passed to next'.

D The server crashes with an uncaught exception.

💡 Hint

What does calling next() with an error do in Express?

Calling next() with an error passes control to the error-handling middleware, which sends the 500 response with the error message.

❓ component_behavior

advanced

Which middleware order causes synchronous errors to be caught correctly?

Given these middleware registrations, which order ensures synchronous errors thrown in routes are caught by the error handler?

Express

const express = require('express');
const app = express();

function errorHandler(err, req, res, next) {
  res.status(500).send('Error: ' + err.message);
}

function routeHandler(req, res) {
  throw new Error('Oops');
}

// Options show different orders of app.use and app.get calls

A

app.use(errorHandler);
app.get('/', routeHandler);

B

app.get('/', routeHandler);
app.use(errorHandler);

C

app.use(routeHandler);
app.use(errorHandler);

D app.get('/', routeHandler);

💡 Hint

Error-handling middleware must be registered after routes to catch their errors.

Express calls middleware in order. The error handler must come after routes to catch errors thrown by them.

📝 Syntax

advanced

Which error-handling middleware signature is correct for synchronous errors?

Which of these middleware functions is correctly defined to catch synchronous errors in Express?

A (req, res) => { throw new Error('Error'); }

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

C (err, req, res) => { res.status(500).send(err.message); }

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

💡 Hint

Error-handling middleware must have four parameters.

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

🔧 Debug

expert

Why does this synchronous error crash the Express server?

This code throws a synchronous error inside a route, but the server crashes instead of sending a response. Why?

Express

const express = require('express');
const app = express();

app.get('/', (req, res) => {
  throw new Error('Crash!');
});

app.listen(3000);

A No error-handling middleware is defined to catch the thrown error.

B The error is asynchronous and cannot be caught by Express.

C The route handler uses next() incorrectly.

D The server port 3000 is already in use.

💡 Hint

Express needs special middleware to catch errors and prevent crashes.

Without error-handling middleware, synchronous errors thrown in routes crash the server.