Passing variables to the next middleware using next() in Express.js

javascript

middleware

express-js

best-practices

byNikita Barsukov·Nov 18, 2024

To facilitate data exchange between middlewares in Express.js, simply attach properties to the request object (req). These properties are accessible through the same req object in the subsequent middleware.

Consider req.userDetails as an example:

app.use((req, res, next) => {
  // Injecting a little 'Alice' in our 'Wonderland'
  req.userDetails = { name: 'Alice' };
  next();
});

app.use((req, res) => {
  // We found 'Alice'! 🙂
  console.log(req.userDetails); // Outputs: { name: 'Alice' }
});

This leads to a straightforward transfer of data down the middleware pipeline.

Variable passing with style

While req can indeed be used, the truly stylish Express devs prefer using another method: **res.locals**.

Treating res.locals as the exclusive shelf for your data ensures that your makes it through the request-response cycle in one piece.

app.use((req, res, next) => {
  // 'res.locals', a posh spot for our 'Alice'
  res.locals.userDetails = { name: 'Alice' };
  next();
});

app.use((req, res) => {
  // 'Alice' found the posh spot! 👌
  console.log(res.locals.userDetails); // Outputs: { name: 'Alice' }
});

Practice this approach to avoid accidental data wipeouts and keep your req neat and tidy.

Know your playing field

Remember, variables added to res.locals are available down the middleware chain, but aren't globally accessible. This differs from app.locals, which is great for templates but less useful for middleware actions. Therefore, using -scoped variables with res.locals helps avoiding "name clashes".

Precautionary measures

Avoid modifying req directly unless absolutely necessary. If passing variables across several middlewares becomes a chore, it's time to revisit your code structure. The need for extensive data surfing might signal underlying design issues.

Practices for smooth transitions

Naming is crucial: Avoid name clashes by using unique prefixes or namespaces.
Know the lifecycle: Delete data in res.locals when no longer needed.
Middleware wisdom: Complex logic? Services and modules can be handy.
Master your tools: Use middlewares like cookie-parser or express-session for specialized tasks.

Real-life parallels

Consider an authentication process. After the user is validated, the information needs to be passed onto other middlewares. res.locals is your trusted buddy in achieving it without bloating the req object.

app.use(authenticateUser);

function authenticateUser(req, res, next) {
  // ...authentication logic...
  if (authenticated) {
    // 'Alice' gets her VIP lounge 😉
    res.locals.user = userDetails;
    next();
  } else {
    // Handle authentication error
  }
}

// In a subsequent middleware
app.use((req, res) => {
  if (res.locals.user) {
    console.log(`Welcome ${res.locals.user.name}`); // 'Alice' spotted!
  }
});