Middleware concept and execution flow in Node.js - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is middleware in Node.js?

Middleware is a function that runs during the request-response cycle. It can modify the request or response objects, end the request, or pass control to the next middleware.

beginner

How does middleware execution flow work in Express.js?

Middleware functions run in the order they are added. Each middleware calls next() to pass control to the next one. If next() is not called and the response is not ended, the request stops there.

intermediate

What happens if a middleware does not call next()?

The request-response cycle stops at that middleware. The server will not continue to the next middleware or route handler, possibly causing the request to hang.

beginner

What are common uses of middleware in Node.js?

Middleware is used for logging, authentication, parsing request bodies, error handling, and serving static files.

intermediate

Explain the difference between application-level and error-handling middleware.

Application-level middleware handles normal requests and calls next() to continue. Error-handling middleware has four parameters (err, req, res, next) and handles errors passed down the chain.

What does the next() function do in middleware?

A Ends the request-response cycle

B Throws an error

C Sends a response to the client

D Passes control to the next middleware

Calling next() passes control to the next middleware or route handler in the stack.

Which of these is NOT a typical use of middleware?

A Rendering HTML templates

B Parsing JSON bodies

C Handling authentication

D Logging requests

Rendering HTML is usually done in route handlers or view engines, not middleware.

What happens if middleware does not call next() or end the response?

A The request continues normally

B The request hangs and never completes

C The server crashes

D An error is automatically thrown

Without calling next() or ending the response, the request stays open and the client waits indefinitely.

How many parameters does an error-handling middleware function have?

A 2

B 3

C 4

D 1

Error-handling middleware has four parameters: (err, req, res, next).

In Express.js, middleware functions are executed in:

A The order they are added

B Random order

C Alphabetical order

D Reverse order

Middleware runs in the order they are added to the app or router.

Describe what middleware is and how it controls the flow of requests in a Node.js app.

Think about how functions can be chained to handle requests step-by-step.

Explain the difference between normal middleware and error-handling middleware in Express.js.

Focus on the special signature and role of error middleware.

Practice

1. What is the main purpose of middleware in a Node.js Express app?

easy

A. To style the HTML pages

B. To directly send responses to the client without routes

C. To define database schemas

D. To run code on requests before they reach the route handlers

Solution

1. Step 1: Understand middleware role and compare options

   Middleware functions run before route handlers to process requests. Only To run code on requests before they reach the route handlers describes middleware's role correctly; others describe unrelated tasks.

2. Final Answer:

   To run code on requests before they reach the route handlers -> Option D

3. Quick Check:

   Middleware = Pre-route code [OK]

Hint: Middleware runs before routes to handle requests [OK]

Common Mistakes:

• Thinking middleware sends responses directly
• Confusing middleware with database logic
• Assuming middleware styles pages

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

easy

A. app.get((req, res) => { console.log('Middleware'); });

B. app.use((req, res, next) => { console.log('Middleware'); next(); });

C. app.middleware((req, res, next) => { next(); });

D. app.route('/').middleware((req, res) => { next(); });

Solution

1. Step 1: Recall Express middleware syntax and check options

   Middleware uses app.use() with (req, res, next) parameters. Only app.use((req, res, next) => { console.log('Middleware'); next(); }); uses app.use() and calls next(), which is correct middleware syntax.

2. Final Answer:

   app.use((req, res, next) => { console.log('Middleware'); next(); }); -> Option B

3. Quick Check:

   Middleware = app.use + next() [OK]

Hint: Middleware uses app.use and calls next() [OK]

Common Mistakes:

• Using app.get instead of app.use for middleware
• Missing next() call inside middleware
• Using non-existent app.middleware method

3. Consider this Express code:

app.use((req, res, next) => { console.log('First'); next(); });
app.use((req, res, next) => { console.log('Second'); next(); });
app.get('/', (req, res) => { res.send('Done'); });

What will be printed in the console when a GET request is made to '/'?

medium

A. First\nSecond

B. Second\nFirst

C. Done

D. No output

Solution

1. Step 1: Understand middleware execution order and route handler

   Middleware runs in the order added: first prints 'First', then calls next(), second prints 'Second'. After middleware, route handler sends response but does not print to console.

2. Final Answer:

   First\nSecond -> Option A

3. Quick Check:

   Middleware order = console logs order [OK]

Hint: Middleware logs appear in order added before route runs [OK]

Common Mistakes:

• Assuming route handler logs to console
• Thinking middleware runs in reverse order
• Missing next() causes no further logs

4. What is the problem with this middleware code?

app.use((req, res, next) => { console.log('Start'); });
app.get('/', (req, res) => { res.send('Hello'); });

medium

A. It calls next() twice, causing an error

B. It sends response twice, causing an error

C. It never calls next(), so the request hangs

D. It uses wrong parameters in middleware function

Solution

1. Step 1: Check middleware function and request flow effect

   The middleware logs 'Start' but does not call next(), so it blocks further processing. Without next(), the route handler never runs, so the request hangs.

2. Final Answer:

   It never calls next(), so the request hangs -> Option C

3. Quick Check:

   Missing next() blocks request [OK]

Hint: Always call next() in middleware unless sending response [OK]

Common Mistakes:

• Forgetting to call next() in middleware
• Calling next() multiple times
• Confusing middleware parameters

5. You want to add two middleware functions to log request time and check authentication before handling routes. Which code correctly ensures both run in order and the route handler executes after?

hard

A. app.use((req, res, next) => { console.log('Time:', Date.now()); next(); });\napp.use((req, res, next) => { if(req.user) next(); else res.status(401).send('Unauthorized'); });\napp.get('/', (req, res) => { res.send('Welcome'); });

B. app.use((req, res) => { console.log('Time:', Date.now()); });\napp.use((req, res, next) => { if(req.user) next(); else res.status(401).send('Unauthorized'); });\napp.get('/', (req, res) => { res.send('Welcome'); });

C. app.use((req, res, next) => { if(req.user) next(); else res.status(401).send('Unauthorized'); });\napp.use((req, res, next) => { console.log('Time:', Date.now()); next(); });\napp.get('/', (req, res) => { res.send('Welcome'); });

D. app.get('/', (req, res) => { console.log('Time:', Date.now()); });\napp.use((req, res, next) => { if(req.user) next(); else res.status(401).send('Unauthorized'); });

Solution

1. Step 1: Check middleware order, next() calls, and route handler execution

   app.use((req, res, next) => { console.log('Time:', Date.now()); next(); });\napp.use((req, res, next) => { if(req.user) next(); else res.status(401).send('Unauthorized'); });\napp.get('/', (req, res) => { res.send('Welcome'); }); runs time logger first, calls next(), then auth check middleware, which calls next() or sends response. Only if both middleware call next(), the route handler runs and sends 'Welcome'.

2. Final Answer:

   app.use((req, res, next) => { console.log('Time:', Date.now()); next(); });\napp.use((req, res, next) => { if(req.user) next(); else res.status(401).send('Unauthorized'); });\napp.get('/', (req, res) => { res.send('Welcome'); }); -> Option A

3. Quick Check:

   Middleware order + next() = correct flow [OK]

Hint: Middleware must call next() to continue chain in correct order [OK]

Common Mistakes:

• Missing next() in first middleware
• Reversing middleware order
• Using app.get instead of app.use for middleware