404 Not Found handler in Express - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a 404 Not Found handler in Express?

It is a middleware function that catches requests to routes that do not exist and sends a 404 status with a message to the client.

beginner

Where should you place the 404 Not Found handler in your Express app?

It should be placed after all other route handlers so it only runs if no route matches the request.

beginner

How do you send a 404 status code in Express?

Use res.status(404).send('Not Found') or res.status(404).json({ message: 'Not Found' }) inside the handler.

beginner

Example code snippet for a simple 404 Not Found handler in Express?

app.use((req, res) => { res.status(404).send('404 Not Found'); });

beginner

Why is it important to have a 404 Not Found handler in your Express app?

It improves user experience by clearly telling users when a page or resource does not exist, instead of leaving them with a blank or confusing error.

Where should the 404 Not Found handler be placed in an Express app?

A It does not matter

B Before all route handlers

C In the middle of route handlers

D After all other route handlers

The 404 handler runs only if no other route matches, so it must be last.

What status code does a 404 Not Found handler send?

A 404

B 200

C 500

D 302

404 means the requested resource was not found.

Which Express method sets the HTTP status code in the response?

A res.status()

B res.setStatus()

C res.sendStatus()

D res.code()

res.status() sets the status code before sending the response.

What happens if you do not add a 404 handler in Express?

A Express automatically sends a 404 response

B The server crashes

C The request hangs or returns a default response

D The request is redirected

Without a 404 handler, requests to unknown routes may hang or get a default empty response.

How do you define a 404 handler middleware in Express?

A app.get('/404', ...)

B app.use((req, res) => { ... })

C app.post('/404', ...)

D app.route('/404')

A 404 handler uses app.use with a function that handles unmatched requests.

Explain how to create and use a 404 Not Found handler in an Express app.

Think about middleware order and response status

Why is a 404 Not Found handler important for user experience in web apps?

Consider what happens if users get no feedback

Practice

1. What is the main purpose of a 404 Not Found handler in an Express app?

easy

A. To catch requests for routes that do not exist and respond with a message

B. To handle database connection errors

C. To log all incoming requests

D. To serve static files like images and CSS

Solution

1. Step 1: Understand what a 404 error means

   A 404 error means the requested page or route was not found on the server.

2. Step 2: Role of the 404 handler in Express

   The 404 handler catches these unknown routes and sends a clear message to the user.

3. Final Answer:

   To catch requests for routes that do not exist and respond with a message -> Option A

4. Quick Check:

   404 handler = catch unknown routes [OK]

Hint: 404 handler catches unknown routes last in middleware [OK]

Common Mistakes:

• Confusing 404 handler with error handler for server errors
• Placing 404 handler before route definitions
• Using 404 handler to serve static files

2. Which of the following is the correct syntax to add a 404 handler in Express?

easy

A. app.route('*').get((req, res) => { res.status(404).send('Not Found'); });

B. app.get('/404', (req, res) => { res.send('Not Found'); });

C. app.use((req, res) => { res.status(404).send('Not Found'); });

D. app.use((err, req, res, next) => { res.status(404).send('Not Found'); });

Solution

1. Step 1: Identify the middleware signature for 404 handler

   A 404 handler uses app.use with (req, res) parameters, no error parameter.

2. Step 2: Check each option's correctness

   app.use((req, res) => { res.status(404).send('Not Found'); }); correctly uses app.use with (req, res) and sets status 404. app.get('/404', (req, res) => { res.send('Not Found'); }); is a route, not a catch-all. app.use((err, req, res, next) => { res.status(404).send('Not Found'); }); is an error handler (has err param). app.route('*').get((req, res) => { res.status(404).send('Not Found'); }); uses app.route('*') which is not standard for 404.

3. Final Answer:

   app.use((req, res) => { res.status(404).send('Not Found'); }); -> Option C

4. Quick Check:

   404 handler = app.use with (req, res) [OK]

Hint: 404 handler uses app.use with (req, res), no error param [OK]

Common Mistakes:

• Using error handler signature (err, req, res, next) for 404
• Defining 404 as a specific route like '/404'
• Using app.route('*') incorrectly for 404

3. Given this Express code snippet, what will the server respond with when a user visits /unknown?

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

app.get('/home', (req, res) => {
  res.send('Welcome Home');
});

app.use((req, res) => {
  res.status(404).send('Page Not Found');
});

app.listen(3000);

medium

A. No response, request hangs

B. 'Welcome Home'

C. Server error 500

D. 'Page Not Found' with status 404

Solution

1. Step 1: Check defined routes

   The only defined route is '/home'. The request is for '/unknown', which is not defined.

2. Step 2: Check 404 handler behavior

   The app.use middleware catches all unmatched routes and sends 'Page Not Found' with status 404.

3. Final Answer:

   'Page Not Found' with status 404 -> Option D

4. Quick Check:

   Unknown route triggers 404 handler [OK]

Hint: Unknown routes trigger 404 handler last middleware [OK]

Common Mistakes:

• Assuming default 200 status for unknown routes
• Expecting server error instead of 404
• Thinking the request will hang without response

4. Identify the error in this Express 404 handler code:

app.use((req, res, next) => {
  res.send('404 Not Found');
  res.status(404);
});

medium

A. The status should be set before sending the response

B. The handler should have four parameters (err, req, res, next)

C. The handler should use res.redirect instead of res.send

D. The middleware should be app.get, not app.use

Solution

1. Step 1: Check order of response methods

   Calling res.send sends the response immediately. Setting status after sending has no effect.

2. Step 2: Correct order for setting status and sending

   Status must be set before res.send to apply correctly.

3. Final Answer:

   The status should be set before sending the response -> Option A

4. Quick Check:

   Set status before send [OK]

Hint: Always set status before sending response [OK]

Common Mistakes:

• Setting status after res.send (ignored)
• Using error handler signature for 404
• Using app.get instead of app.use for 404

5. You want to add a 404 handler that returns JSON with a message and logs the missing URL. Which code correctly implements this in Express?

hard

A. app.use((err, req, res, next) => { console.log('Missing:', req.url); res.status(404).json({ error: 'Not Found' }); });

B. app.use((req, res) => { console.log('Missing:', req.url); res.status(404).json({ error: 'Not Found' }); });

C. app.get('*', (req, res) => { console.log('Missing:', req.url); res.status(404).json({ error: 'Not Found' }); });

D. app.use((req, res, next) => { res.json({ error: 'Not Found' }); console.log('Missing:', req.url); res.status(404); });

Solution

1. Step 1: Choose correct middleware signature for 404 handler

   404 handler uses app.use with (req, res), no error parameter.

2. Step 2: Ensure status is set before sending JSON and logging happens before response

   app.use((req, res) => { console.log('Missing:', req.url); res.status(404).json({ error: 'Not Found' }); }); logs the URL, sets status 404, and sends JSON correctly. app.use((err, req, res, next) => { console.log('Missing:', req.url); res.status(404).json({ error: 'Not Found' }); }); uses error handler signature incorrectly. app.get('*', (req, res) => { console.log('Missing:', req.url); res.status(404).json({ error: 'Not Found' }); }); uses app.get('*') which is less common and may miss some requests. app.use((req, res, next) => { res.json({ error: 'Not Found' }); console.log('Missing:', req.url); res.status(404); }); sets status after sending response and logs after response, which is wrong.

3. Final Answer:

   app.use((req, res) => { console.log('Missing:', req.url); res.status(404).json({ error: 'Not Found' }); }); -> Option B

4. Quick Check:

   404 handler logs then sends JSON with status 404 [OK]

Hint: Use app.use with (req, res), set status before json, log before response [OK]

Common Mistakes:

• Using error handler signature for 404
• Setting status after sending response
• Logging after sending response
• Using app.get('*') instead of app.use