blocks|key|572476|text|middleware|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|572477|我已经在一个新项目中分离了中间件的概念。|572478|中间件允许您定义应该流经的操作堆栈。Express服务器本身就是一堆中间件。|572479|//+express
var+app+=+express();
//+middleware
var+stack+=+middleware();|code-block|syntax|javascript|572480|然后，您可以通过调用.use向中间件堆栈添加层|style|CODE|572481|//+express
app.use(express.static(..));
//+middleware
stack.use(function(data,+next)+{
++next();
});|572482|中间件堆栈中的层是一个函数，它接受n个参数(2个用于express、req和res)和一个next函数。|572483|中间件期望该层进行一些计算，增加参数，然后调用next。|572484|堆栈不会做任何事情，除非你处理它。Express将在每次在服务器上捕获传入的HTTP请求时处理堆栈。使用中间件，您可以手动处理堆栈。|572485|//+express,+you+need+to+do+nothing
//+middleware
stack.handle(someData);|572486|一个更完整的例子：|572487|var+middleware+=+require("../src/middleware.js");

var+stack+=+middleware(function(data,+next)+{
++++data.foo+=+data.data*2;
++++next();
},+function(data,+next)+{
++++setTimeout(function()+{
++++++++data.async+=+true;
++++++++next();
++++},+100)
},+function(data)+{
++++console.log(data);
});

stack.handle({
++++"data":+42
})|572488|在express术语中，您只需定义一个操作堆栈，您希望express为每个传入的HTTP请求处理这些操作。|572489|就express+(而不是connect)而言，您拥有全局中间件和特定于路由的中间件。这意味着您可以将中间件堆栈附加到每个传入的HTTP请求，或者仅将其附加到与特定路由交互的HTTP请求。|572490|express+&中间件的高级示例：|572491|//+middleware+

var+stack+=+middleware(function(req,+res,+next)+{
++++users.getAll(function(err,+users)+{
++++++++if+(err)+next(err);
++++++++req.users+=+users;
++++++++next();++
++++});
},+function(req,+res,+next)+{
++++posts.getAll(function(err,+posts)+{
++++++++if+(err)+next(err);
++++++++req.posts+=+posts;
++++++++next();
++++})
},+function(req,+res,+next)+{
++++req.posts.forEach(function(post)+{
++++++++post.user+=+req.users[post.userId];
++++});

++++res.render("blog/posts",+{
++++++++"posts":+req.posts
++++});
});

var+app+=+express.createServer();

app.get("/posts",+function(req,+res)+{
+++stack.handle(req,+res);+
});

//+express

var+app+=+express.createServer();

app.get("/posts",+[
++++function(req,+res,+next)+{
++++++++users.getAll(function(err,+users)+{
++++++++++++if+(err)+next(err);
++++++++++++req.users+=+users;
++++++++++++next();++
++++++++});
++++},+function(req,+res,+next)+{
++++++++posts.getAll(function(err,+posts)+{
++++++++++++if+(err)+next(err);
++++++++++++req.posts+=+posts;
++++++++++++next();
++++++++})
++++},+function(req,+res,+next)+{
++++++++req.posts.forEach(function(post)+{
++++++++++++post.user+=+req.users[post.userId];
++++++++});

++++++++res.render("blog/posts",+{
++++++++++++"posts":+req.posts
++++++++});
++++}
],+function(req,+res)+{
+++stack.handle(req,+res);+
});|572492|entityMap|0|LINK|mutability|MUTABLE|url|https://expressjs.com/en/guide/using-middleware.html^0|0|A|0|0|0|0|0|A|4|0|0|Y|3|12|3|19|4|0|N|4|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1K|8|@]|9|@$A|1L|B|1M|1|1N]]|C|$]]|$1|D|3|E|5|6|7|1O|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|1P|8|@]|9|@]|C|$]]|$1|H|3|I|5|J|7|1Q|8|@]|9|@]|C|$K|L]]|$1|M|3|N|5|6|7|1R|8|@$A|1S|B|1T|O|P]]|9|@]|C|$]]|$1|Q|3|R|5|J|7|1U|8|@]|9|@]|C|$K|L]]|$1|S|3|T|5|6|7|1V|8|@$A|1W|B|1X|O|P]|$A|1Y|B|1Z|O|P]|$A|20|B|21|O|P]]|9|@]|C|$]]|$1|U|3|V|5|6|7|22|8|@$A|23|B|24|O|P]]|9|@]|C|$]]|$1|W|3|X|5|6|7|25|8|@]|9|@]|C|$]]|$1|Y|3|Z|5|J|7|26|8|@]|9|@]|C|$K|L]]|$1|10|3|11|5|6|7|27|8|@]|9|@]|C|$]]|$1|12|3|13|5|J|7|28|8|@]|9|@]|C|$K|L]]|$1|14|3|15|5|6|7|29|8|@]|9|@]|C|$]]|$1|16|3|17|5|6|7|2A|8|@]|9|@]|C|$]]|$1|18|3|19|5|6|7|2B|8|@]|9|@]|C|$]]|$1|1A|3|1B|5|J|7|2C|8|@]|9|@]|C|$K|L]]|$1|1C|3|-4|5|6|7|2D|8|@]|9|@]|C|$]]]|1D|$1E|$5|1F|1G|1H|C|$1I|1J]]]]

<a href="https://expressjs.com/en/guide/using-middleware.html" rel="noreferrer">middleware</a>

I'm halfway through separating the concept of middleware in a new project. 

Middleware allows you to define a stack of actions that you should flow through. Express servers themselves are a stack of middlewares.

<pre><code>// express
var app = express();
// middleware
var stack = middleware();
</code></pre>

Then you can add layers to the middleware stack by calling <code>.use</code>

<pre><code>// express
app.use(express.static(..));
// middleware
stack.use(function(data, next) {
 next();
});
</code></pre>

A layer in the middleware stack is a function, which takes n parameters (2 for express, <code>req</code> &amp; <code>res</code>) and a <code>next</code> function.

Middleware expects the layer to do some computation, augment the parameters and then call <code>next</code>.

A stack doesn't do anything unless you handle it. Express will handle the stack every time an incoming HTTP request is caught on the server. With middleware you handle the stack manually.

<pre><code>// express, you need to do nothing
// middleware
stack.handle(someData);
</code></pre>

A more complete example :

<pre><code>var middleware = require("../src/middleware.js");

var stack = middleware(function(data, next) {
 data.foo = data.data*2;
 next();
}, function(data, next) {
 setTimeout(function() {
 data.async = true;
 next();
 }, 100)
}, function(data) {
 console.log(data);
});

stack.handle({
 "data": 42
})
</code></pre>

In express terms you just define a stack of operations you want express to handle for every incoming HTTP request.

In terms of express (rather than connect) you have global middleware and route specific middleware. This means you can attach a middleware stack to every incoming HTTP requests or only attach it to HTTP requests that interact with a certain route.

Advanced examples of express &amp; middleware :

<pre><code>// middleware 

var stack = middleware(function(req, res, next) {
 users.getAll(function(err, users) {
 if (err) next(err);
 req.users = users;
 next(); 
 });
}, function(req, res, next) {
 posts.getAll(function(err, posts) {
 if (err) next(err);
 req.posts = posts;
 next();
 })
}, function(req, res, next) {
 req.posts.forEach(function(post) {
 post.user = req.users[post.userId];
 });

 res.render("blog/posts", {
 "posts": req.posts
 });
});

var app = express.createServer();

app.get("/posts", function(req, res) {
 stack.handle(req, res); 
});

// express

var app = express.createServer();

app.get("/posts", [
 function(req, res, next) {
 users.getAll(function(err, users) {
 if (err) next(err);
 req.users = users;
 next(); 
 });
 }, function(req, res, next) {
 posts.getAll(function(err, posts) {
 if (err) next(err);
 req.posts = posts;
 next();
 })
 }, function(req, res, next) {
 req.posts.forEach(function(post) {
 post.user = req.users[post.userId];
 });

 res.render("blog/posts", {
 "posts": req.posts
 });
 }
], function(req, res) {
 stack.handle(req, res); 
});
</code></pre>

blocks|key|572535|text|简化后，web服务器可以看作是接收请求并输出响应的功能。因此，如果您将web服务器视为一个函数，您可以将其组织成几个部分，并将它们分成较小的函数，以便它们的组合将是原始函数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|572536|中间件是较小的功能，您可以与其他功能组合，其明显的好处是您可以重用它们。|572537|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

After simplifying things, a web server can be seen as a function that takes in a request and outputs a response. So if you view a web server as a function, you could organize it into several pieces and separate them into smaller functions so that the composition of them will be the original function.

Middlewares are the smaller functions that you can compose with others and the obvious benefit is that you can reuse them.

blocks|key|788634|text|中间件是在输入/源产生输出之后在中间执行的函数，该输出可能是最终输出，或者可以被下一个中间件使用，直到循环完成。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|788635|它就像一个流水线上的产品，在流水线上进行修改，直到完成、评估或被拒绝。|788636|中间件期望某个值起作用(即参数值)，并且基于某些逻辑，中间件将调用或不调用下一个中间件，或者将响应发送回客户端。|788637|如果您还不能掌握中间件的概念，那么它在某种程度上类似于Decorator或Chain+of+command模式。|788638|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

Middlewares are functions executed in the middle after the input/source then produces an output which could be the final output or could be used by the next middleware until the cycle is complete. 

It is like a product that goes through an assembly line where it gets modified as it moves along until it gets completed, evaluated or gets rejected.

A middleware expects some value to work on (i.e. parameter values) and based on some logic the middleware will call or not call the next middleware or send a response back to the client.

If you can't still grasp the middleware concept, it is in a way similar to the Decorator or Chain of command patterns.

blocks|key|788688|text|中间件是由Express+js路由层在调用用户定义的处理程序之前调用的链式函数的子集。中间件函数可以完全访问请求和响应对象，并且可以修改它们中的任何一个。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|788689|中间件链总是按照定义它的确切顺序进行调用，因此准确地知道特定的中间件在做什么对您来说至关重要。|788690|一旦中间件函数完成，它就会调用链中的下一个函数，方法是调用它的下一个参数作为函数。|788691|在执行完整个链之后，将调用用户请求处理程序。|788692|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

Middleware is a subset of chained functions called by the Express js routing layer before the user-defined handler is invoked. Middleware functions have full access to the request and response objects and can modify either of them. 
The middleware chain is always called in the exact order in which it has been defined, so it is vital for you to know exactly what a specific piece of middleware is doing. Once a middleware function finishes, it calls the next function in the chain by invoking its next argument as function. After the complete chain gets executed,the user request handler is called.

blocks|key|572654|text|简单地说，如果我想这样解释，我是从traversymedia+youtube频道快速速成课程中学到的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|572655|好的，中间件是一个在你调用你的路由后执行的函数，如下所示。|572656|var+logger+=+function(req,+res,+next){
+++console.log('logging...');
+++next();
}

app.use(logger);|code-block|syntax|javascript|572657|这个记录器函数在你每次刷新你的页面时执行，这意味着你可以在你的页面被渲染后写下你需要做的任何事情，任何操作api调用，基本上重置任何东西。并且把这个中间件放在你的路由功能之前中间件的功能顺序是非常重要的，否则它就不能工作|572658|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|O|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

In very basic term if i want to explain it like this i learn this from traversymedia youtube channel express crash course. 
ok so middle ware is a function who execute after you make a call to your route like this.

<pre><code>var logger = function(req, res, next){
 console.log('logging...');
 next();
}

app.use(logger);
</code></pre>

This logger function execute every time you refresh your page that means you can write anything in it that you required to do after your page get rendered any operation api call, reset things basically anything. and put this middleware before your route function order of middleware is really important or it dons't work

Almost every Express app I see has an <code>app.use</code> statement for middleware but I haven't found a clear, concise explanation of what middleware actually is and what the <code>app.use</code> statement is doing. Even the express docs themselves are a bit vague on this. Can you explain these concepts for me please?

What does middleware and app.use actually mean in Expressjs?

中间件

服务器

路由

我看到的几乎每个Express应用程序都有一个用于中间件的app.use语句，但我还没有找到一个清晰、简洁的解释，说明什么是中间件以及app.use语句在做什么。即使是快递文档本身在这一点上也有点模糊。你能给我解释一下这些概念吗？

问在Expressjs中，中间件和app.use到底意味着什么？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Expressjs中，中间件和app.use到底意味着什么？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Expressjs中，中间件和app.use到底意味着什么？
EN