next() function and flow control in Express - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the purpose of the next() function in Express middleware?

The next() function tells Express to move to the next middleware or route handler in the stack. It helps control the flow of request processing.

beginner

How does Express decide which middleware or route handler to run next?

Express runs middleware and route handlers in the order they are added. Calling next() moves to the next matching middleware or route handler.

intermediate

What happens if you forget to call next() in a middleware?

The request will hang because Express waits for next() to continue. The response might never be sent, causing the client to wait forever.

intermediate

How can next() be used to handle errors in Express?

If you pass an error to next(error), Express skips normal middleware and goes to error-handling middleware. This helps manage errors cleanly.

intermediate

Explain the flow control when multiple middleware functions are used in an Express route.

Each middleware runs in order. When a middleware calls next(), Express moves to the next middleware. If a middleware sends a response without calling next(), the chain stops.

What does calling next() inside an Express middleware do?

A Restarts the server

B Ends the request and sends a response

C Moves to the next middleware or route handler

D Logs the request details

Calling next() tells Express to continue to the next middleware or route handler.

If a middleware does not call next() or send a response, what happens?

A The request hangs and never completes

B Express automatically calls <code>next()</code>

C The server crashes

D The client receives a default response

Without calling next() or sending a response, Express waits indefinitely, causing the request to hang.

How do you pass an error to Express error-handling middleware?

A Call <code>next(error)</code> with an error object

B Throw an error inside middleware

C Return <code>false</code> from middleware

D Call <code>res.send(error)</code>

Passing an error object to next() triggers Express to skip normal middleware and run error handlers.

In what order does Express run middleware functions?

A Reverse order of addition

B Alphabetical order by function name

C Random order

D In the order they are added to the app

Express runs middleware in the order they are registered in the code.

What happens if a middleware sends a response but also calls next()?

A Express ignores the response and continues

B It can cause errors because the response is already sent

C The response is sent twice safely

D The server restarts

Sending a response and then calling next() can cause errors because Express tries to continue processing after the response is finished.

Describe how the next() function controls the flow of middleware in Express.

Think about how Express knows what to do after one middleware finishes.

Explain what happens if you forget to call next() in a middleware function.

Imagine a line of people waiting and one person never passes the message forward.

Practice

1. What does the next() function do in Express middleware?

easy

A. It logs the request details to the console.

B. It passes control to the next middleware or route handler.

C. It restarts the current middleware from the beginning.

D. It ends the request and sends a response to the client.

Solution

1. Step 1: Understand middleware flow

   Express middleware functions run in sequence. Calling next() moves control to the next middleware or route.

2. Step 2: Identify next() role

   Calling next() does not send a response but passes control forward, allowing the app to continue processing.

3. Final Answer:

   It passes control to the next middleware or route handler. -> Option B

4. Quick Check:

   next() moves control forward [OK]

Hint: Remember: next() moves to next step, doesn't send response [OK]

Common Mistakes:

• Thinking next() sends a response
• Confusing next() with ending the request
• Assuming next() restarts middleware

2. Which of the following is the correct syntax to use next() in an Express middleware function?

easy

A. function(req, res, next) { res.next(); }

B. function(req, res) { next(); }

C. function(req, res, next) { next(); }

D. function(req, res, next) { next; }

Solution

1. Step 1: Check middleware parameters

   Express middleware must have three parameters: req, res, and next to use next().

2. Step 2: Verify calling next()

   The correct way to call next() is as a function with parentheses: next();

3. Final Answer:

   function(req, res, next) { next(); } -> Option C

4. Quick Check:

   Correct syntax includes next as parameter and calls next() [OK]

Hint: next() must be called as a function with parentheses [OK]

Common Mistakes:

• Omitting next parameter
• Calling next without parentheses
• Using res.next() instead of next()

3. Consider this Express middleware chain:

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

What will be printed in the console when a request is made?

medium

A. First\nSecond

B. First\nSecond\nThird

C. Second\nThird

D. First

Solution

1. Step 1: Trace middleware execution order

   The first middleware logs 'First' and calls next(), so the second middleware runs next.

2. Step 2: Check response and flow stop

   The second middleware logs 'Second' and sends a response with res.send('Done'). Sending a response ends the request, so the third middleware does not run.

3. Final Answer:

   First\nSecond -> Option A

4. Quick Check:

   Response sent stops flow, so third middleware skipped [OK]

Hint: Sending response stops middleware chain immediately [OK]

Common Mistakes:

• Assuming all middleware run even after response
• Thinking next() runs after res.send()
• Ignoring that res.send ends request

4. What is wrong with this Express middleware?

app.use((req, res, next) => {
  console.log('Logging request');
  // forgot to call next or send response
});

medium

A. It will cause the request to hang and never finish.

B. It will automatically call next() after logging.

C. It will send an empty response to the client.

D. It will throw a syntax error.

Solution

1. Step 1: Identify missing flow control

   The middleware logs a message but neither calls next() nor sends a response.

2. Step 2: Understand Express behavior

   Without calling next() or sending a response, Express waits indefinitely, causing the request to hang.

3. Final Answer:

   It will cause the request to hang and never finish. -> Option A

4. Quick Check:

   Missing next() or response causes hanging [OK]

Hint: Always call next() or send response to finish middleware [OK]

Common Mistakes:

• Assuming Express auto-calls next()
• Thinking console.log ends request
• Expecting default response without sending

5. You want to create middleware that checks if a user is logged in. If not logged in, it should send a 401 response. If logged in, it should continue to the next middleware. Which code correctly uses next() to achieve this?

hard

A. app.use((req, res, next) => {
if (!req.user) {
next();
} else {
res.status(401).send('Unauthorized');
}
});

B. app.use((req, res, next) => {
next();
if (!req.user) {
res.status(401).send('Unauthorized');
}
});

C. app.use((req, res, next) => {
if (req.user) {
res.status(401).send('Unauthorized');
} else {
next();
}
});

D. app.use((req, res, next) => {
if (!req.user) {
res.status(401).send('Unauthorized');
} else {
next();
}
});

Solution

1. Step 1: Check user login condition

   If req.user is missing, the middleware should send a 401 Unauthorized response immediately.

2. Step 2: Use next() correctly

   If the user is logged in, call next() to pass control to the next middleware or route handler.

3. Final Answer:

   Middleware sends 401 if no user, else calls next() -> Option D

4. Quick Check:

   Send response before next(), or call next() to continue [OK]

Hint: Send response first if unauthorized; call next() only if authorized [OK]

Common Mistakes:

• Calling next() before sending response
• Swapping conditions for sending response
• Calling next() after sending response