nodejs operates next in express

This time I will bring you nodejs to operate next in express. What are the precautions for nodejs to operate next in express? The following is a practical case, let’s take a look.

I believe that many people don’t know much about next in express in nodejs. Most people don’t know what role next has and under what circumstances it is used. Today’s article will give you a detailed introduction to it. If you are interested, let’s learn how to use it.

Recently, the company is using node to separate the front and back ends. The web framework used is express, so I have an in-depth understanding of the express framework. I wrote an article about express routing some time ago, but there seems to be one important thing missing in that article. The content is the next of express, so today I will talk about the next of express separately.

Regarding next, I will mainly explain it from three points:

• What is the function of next?

• When should we use next?

What is the internal implementation mechanism of next?

The role of Next

When we define the express

middleware function, we will define the third parameter as next. This next is our protagonist today. The next function is mainly responsible for passing control to the next middleware. If the current middleware If the request is not terminated by the software and next is not called, the request will be suspended and the middleware defined later will not get a chance to be executed.

When to use Next

From the above description, we already know that the next function is mainly used to ensure that all registered middleware are executed one after another. Then we should call the next function in all middleware, but there is a special case. If we define The middleware terminates this request, so the next function should not be called again, otherwise problems may occur. Let's take a look at the code

app.get('/a', function(req, res, next) {
  res.send('sucess');
  next();
});
// catch 404 and forward to error handler
app.use(function(req, res, next) {
 console.log(404);
 var err = new Error('Not Found');
 err.status = 404;
 next(err);
});
app.use(function(err, req, res, next) {
 res.status(err.status || 500);
 res.render('error', {
  message: err.message,
  error: {}
 });
});

Send request "/a", the console print log is as follows:

404
GET /a 500 6.837 ms - -
Error: Can't set headers after they are sent.
  at ServerResponse.OutgoingMessage.setHeader (_http_outgoing.js:345:11)

Why does the code throw an exception? It's because we called the next function after res.send. Although our request has been terminated, the subsequent 404 middleware will still be executed, and the subsequent middleware tries to go to res. Add attribute values ​​to headers, so the above exception will be thrown.

After reading this, you may have a question. If I don't call the next function after res.send, will the 404 middleware defined later never be executed? Now we delete the next function call after res.send and send the request "/xxx", we will find that the 404 middleware is executed, (ㄒoㄒ), isn't this contradictory to what we said before, our customization The middleware does not call next, but the middleware defined later is still executed. Why is this? It seems I can only ask for help with the source code~~~

Next’s internal mechanism

function next(err) {
  ... //此处源码省略
  // find next matching layer
  var layer;
  var match;
  var route;
  while (match !== true && idx < stack.length) {
   layer = stack[idx++];
   match = matchLayer(layer, path);
   route = layer.route;
   if (typeof match !== 'boolean') {
    // hold on to layerError
    layerError = layerError || match;
   }
   if (match !== true) {
    continue;
   }
   ... //此处源码省略
  }
 ... //此处源码省略
  // this should be done for the layer
  if (err) {
    layer.handle_error(err, req, res, next);
  } else {
   layer.handle_request(req, res, next);
  }
 }

The above is the source code of next in express. In order to explain the problem more easily, the code has been deleted. From the source code above, we can find that there is a

while loop inside the next function. Each loop will take out a layer from the stack. This layer contains routing and middleware information, and then the layer and The requested path will match. If the match is successful, layer.handle_request will be executed and the middleware function will be called. But if the match fails, the next layer (middleware) will be looped.

Now we can explain the problem raised above, why the next function is not called in our custom middleware, but the subsequent 404 middleware will still be executed because the "/xxx" we requested does not match the one we registered. "/a" routes the middleware, so the while loop will continue to execute, and the 404 middleware is matched successfully, so the 404 middleware will be executed.

Note: For middleware registered with app.use, if the path parameter is empty, it defaults to "/", and middleware with a path of "/" matches all requests by default.

One thing needs to be pointed out in particular. In fact, when we define routing

middleware, the third parameter next of the function is not the same next as the third parameter next of the function we define non-routing middleware. What you see above is the next function of non-routing middleware, and the next function of routing middleware is like this

function next(err) {
  if (err && err === 'route') {
   return done();
  }
  var layer = stack[idx++];
  if (!layer) {
   return done(err);
  }
  if (layer.method && layer.method !== method) {
   return next(err);
  }
  if (err) {
   layer.handle_error(err, req, res, next);
  } else {
   layer.handle_request(req, res, next);
  }
 }

这个next比上边的那个next要简单很多，它负责同一个路由的多个中间件的控制权的传递，并且它会接收一个参数"route"，如果调用next(“route”)，则会跳过当前路由的其它中间件，直接将控制权交给下一个路由。

最后有必要再说一说next(err)，next(err)是如何将控制权传递到错误处理中间件的，从前边的代码我们知道，当调用next(err)是，express内部会调用layer.handle_error，那我们来看看它的源码

Layer.prototype.handle_error = function handle_error(error, req, res, next) {
 var fn = this.handle;
 if (fn.length !== 4) {
  // not a standard error handler
  return next(error);
 }
 try {
  fn(error, req, res, next);
 } catch (err) {
  next(err);
 }
};

代码中的fn就是中间件函数，express会对fn的参数个数进行判断，如果参数个数不等于4则认为不是错误处理中间件，则继续调用next(err)，这样就会进入到下一个中间件函数，继续进行参数个数判断，如此方式一直到某个中间件函数的参数个数是4，就认为找到了错误处理中间件，然后执行此中间件函数。

相信看了本文案例你已经掌握了方法，更多精彩请关注php中文网其它相关文章！

推荐阅读：

Express Session实现登录验证功能（附代码）

js面向对象深入理解

The above is the detailed content of nodejs operates next in express. For more information, please follow other related articles on the PHP Chinese website!