next() function and flow control in Express - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to call the next middleware function in Express.

Express

app.use((req, res, [1]) => {
  console.log('Middleware 1');
  [1]();
});

Drag options to blanks, or click blank then click option'

Aend

Bsend

Cnext

Dlisten

Attempts:

3 left

💡 Hint

Common Mistakes

Using res.send() instead of next() to continue middleware.

Forgetting to call next() causing the request to hang.

In Express, the next function is used to pass control to the next middleware.

2fill in blank

medium

Complete the code to skip to the next middleware when a condition is met.

Express

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

Drag options to blanks, or click blank then click option'

Ares.redirect

Bnext

Cres.end

Dres.send

Attempts:

3 left

💡 Hint

Common Mistakes

Sending a response and then calling next(), which causes errors.

Not calling next() and blocking the request.

Calling next() passes control to the next middleware if the user exists.

3fill in blank

hard

Fix the error in the middleware to properly handle errors and pass them to the error handler.

Express

app.use((req, res, next) => {
  try {
    throw new Error('Something went wrong');
  } catch (err) {
    [1](err);
  }
});

Drag options to blanks, or click blank then click option'

Anext

Bconsole.log

Cres.status

Dres.send

Attempts:

3 left

💡 Hint

Common Mistakes

Logging the error but not passing it to next(), so error handlers are not triggered.

Sending a response inside catch and then calling next(), causing headers errors.

Passing the error to next(err) tells Express to skip normal middleware and go to error handlers.

4fill in blank

hard

Fill both blanks to create middleware that logs the request and then passes control to the next middleware.

Express

app.use(([1], [2], next) => {
  console.log(`Request URL: $[1].url`);
  next();
});

Drag options to blanks, or click blank then click option'

Areq

Bres

Crequest

Dresponse

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong parameter names that don't match Express conventions.

Forgetting to call next() to continue the middleware chain.

The first two parameters are req and res by convention in Express middleware.

5fill in blank

hard

Fill all three blanks to create error-handling middleware that logs the error and sends a 500 response.

Express

app.use(([1], [2], [3], next) => {
  console.error([1].message);
  [3].status(500).send('Server Error');
});

Drag options to blanks, or click blank then click option'

Aerr

Bres

Creq

Dnext

Attempts:

3 left

💡 Hint

Common Mistakes

Mixing up the order of parameters in error middleware.

Not sending a response after logging the error.

Error-handling middleware has four parameters: err, req, res, and next. Here, err is used to log the error, res to send the response, and req is the request object.

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