Nodejs koa2 框架中的中间件同步还是异步的问题？
Nodejs koa2 框架中的中间件同步还是异步的问题？
问题 1：为什么 koa2 框架中的中间件要用 async 的形式写，很少见用同步模式(即不加 async)？ 如：
app.use(async (ctx, next) => {
const start = new Date()
await next()
const ms = new Date() - start
console.log(`${ctx.method} ${ctx.url} - ${ms}ms`)
})
查阅了一些资料，看到阮一峰的 koa 教程中，有同步写法的例子：
const one = (ctx, next) => {
console.log('>> one');
next();
console.log('<< one');
}
const two = (ctx, next) => {
console.log(’>> two’);
next();
console.log(’<< two’);
}
const three = (ctx, next) => {
console.log(’>> three’);
next();
console.log(’<< three’);
}
app.use(one);
app.use(two);
app.use(three);
这里完全没有 async 的出现，阮神只是在后面提到： “迄今为止，所有例子的中间件都是同步的，不包含异步操作。如果有异步操作（比如读取数据库），中间件就必须写成 async 函数。”
接着找资料发现 koa2 中间件的 next 返回的是 promise，因为源码中的 dispatch(i)返回的就是 promise， 这样我又有一个疑问， 问题 2：为什么要设计成返回 promise ？不返回 promise 就达不到中间件串联的效果吗？ 因为中间件的执行在理解上是一个同步的过程，所以设计成异步要怎么去理解？？
问题 3：是不是用 koa2 写的代码都存在很多 async 的 function(公司项目代码到处都是 async 的，返回输出 json 的时候也需要 async 吗？)？ 有没有不需要写 async 的场景或者例子？
看了几遍才看懂你的疑问，其实光看阮一峰这个例子好有误导性呀。
“迄今为止，所有例子的中间件都是同步的，不包含异步操作。如果有异步操作（比如读取数据库），中间件就必须写成 async 函数。”
只要有一个是异步的，如果要保持这个例子的输出，就必须要用 async 和 await。
假如这个例子只有 one 和 two，把 two 换成异步
例一<br>const one = (ctx, next) => {<br> console.log('>> one');<br> next();<br> console.log('<< one');<br>}<br>const two = (ctx, next) => {<br> console.log('>> two');<br> setTimemout(() => {<br> next();<br> console.log('<< two');<br> });<br>}<br>
你这个时候输出的将会是 >> one >> two <<one <<two。
然而中间件希望的输出是 >> one >> two << two << one。
所以你需要
例二<br>const one = async (ctx, next) => {<br> console.log('>> one');<br> await next();<br> console.log('<< one');<br>}<br>const two = (ctx, next) => {<br> console.log('>> two');<br> setTimemout(() => {<br> next();<br> console.log('<< two');<br> });<br>}<br>
这就是为什么 next 要返回 promise。只有全部 promise 才能达到你预期的状态。
三个问题一起解答，当你期望的执行顺序是例一的时候可以不用 async，这样比较混乱，因为你不知道你后面的中间件有多少异步多少同步，无法预测执行顺序，所以 koa 的中间件思想就是例二这种，不管 two 是不是异步，执行顺序都不会变。
Koa2 已经不推荐使用 Generator 函数，换成 Async 函数了。另外，Koa 用的是洋葱模型，所以理论上是得加上 await 的，不加的话，next 会被放到异步里面去了，就不是洋葱模型了
我觉得你们都没有真正能解答我的问题，我知道 async/await 以及 promise 的用法，只是不明白为什么 next 要返回 promise，为什么中间件要写成 async 的形式，因为如果全部都不写 async 的话也能达到目的，仅仅是为了配合 next 返回的 promise 而使用 await 进而要用 async 包裹起函数作为中间件这种说法显然不能说服我。。。另外 的回答差不多是那么个意思但是我还是不能尽然明白…
先考虑目的:实现洋葱模型，这是 koa 基本思想，理由够充分，可以从阮一峰的例子了解这个模型。
然后再考虑方式，用 async。如果不返回 promise，不用 async，当有中间件用异步的时候，无法实现洋葱模型，如例 2。或者你可以自己试试？
当然，回调，promise，generator，async 都可以实现，但是 async 更优雅。
从错误处理的角度来说，如果你的中间件有一个不返回 promise，那么你的
try{
next()
} catch(e){
}
就不能捕获错误。
所以即使同步的中间件，也应该写成这种。
(ctx,next)=>{
xxx
return next().then(xxx);
}
我提问之前就试过，这是我的测试代码：
const one = (ctx, next) => {
console.log(’>> one’);
next();
console.log(’<< one’);
}
const two = async (ctx, next) => {
console.log(’>> two’);
await next();
console.log(’<< two’);
}
const three = async (ctx, next) => {
console.log(’>> three’);
await next();
console.log(’<< three’);
}
app.use(one);
app.use(two);
app.use(three);
//output:
>> one
>> two
>> three
<< one
<< three
<< two
当全部不使用 async 的时候，是能按照洋葱模型返回的
或者你能不能解释一下我这样测试的执行过程是怎么样的，看看是否与我的想法相符？
ps：不是想做伸手党，只是想找个人验证一下想法…
你的这种写法返回的还是 promise，是属于 koa2 中支持的中间件写法之一，其实跟 await 没有太大区别，这样我还是没有能明白对我的疑问有什么帮助…（哭）
比如你说的例子:<br>app.use(async (ctx, next) => {<br> const start = new Date()<br> next()<br> const ms = new Date() - start<br> console.log(`${ctx.method} ${ctx.url} - ${ms}ms`)<br>})<br><br>app.use(async (ctx, next) => {<br> return new Promise(resolve => {<br> setTimeout(function(){<br> resolve("🙃");<br> }, 1000);<br> });<br> await next()<br>})<br>
这时候你再看看第一个中间件执行时间是多少.
从能运行的角度是可以的。但是从错误处理的角度，如果你不是每个中间件都返回一个 promise，那么你的中间件错误处理就可能有问题。
如果有一个中间件写成同步的模式，那么这中间件后面的错误就不能被
try{
next()
} catch(e){
}
捕获。
如果所有中间件都是同步的. 那你不用异步也可以.
一旦之后的中间件可能是异步的, 那么前面的中间件都要是异步的, 并且要 await(等待) next() 执行完成.
你说的能，是因为后面的中间件没有异步，而后端代码有异步才是普遍情况，假如有异步：
1. 使用 await next()会等你后面的中间件的异步全部执行完，再执行 next()后面的代码：
>>one
…其他中间件，包含同步和异步…
<<one
2. 而不使用 await 的情况，执行顺序是：
>>one
…其他中间件的同步…
<<one
其他中间件的异步
我需要的是最外层的>>one 最先执行，然后<<one 最后执行，2 的输出不符合模型
之所以使用 async 的原因，是因为它可以 await 一个 Promise。这样就是完美的中间件了。阮一峰那个 blog 应该还是停留在 Koa1.0 的时代，现在 Koa2.x 已经提倡使用 async 了。async 天然的可以等待一个 Promise 执行完成。你想象以下，你现在有个需求，接收到用户上传的文件，然后处理文件以后返回提示信息。如果不使用 async，那么你在 Promise 还没执行完就会返回信息了。现在只需要 await next()。然后再返回信息。其实本质上就是把整个过程变成了同步执行的了，但是这样做的好处是选择面更强了，因为它满足了洋葱一层一层的模型。还有个原因是因为这是一个约定，如果你调用的其他中间件使用了 async，那么你不使用，那么将无法等待这个中间件的执行。换句话说，async 把一系列的异步函数给顺序调用了，如果不是 async 的话，那么所有的异步函数将没有任何关系。
不知道你有没有见过那个 blog，那个 blog 一直在更新，我看到的文章是 20117 年下半年的，这个时候怎么都是 koa2 了吧？而且我读你的话的前半段，意思就是因为要等待 next 返回的 promise，所以用 await，因为用 await，所以要 async，我觉得这不是一个说得过去的解释…
koa 用的洋葱模型，要求一层层进去再一层层出来。nodejs 是异步的，koa 遵循了这个原则。而以前的异步最大的问题在于，如果要实现洋葱模型，就必须写大量的回调函数。因此就算是 koa1 也是采用了 generator 这种折中的方法。如果你使用过 co，你就会对洋葱模型有感觉了。其实 koa1 内部就是调用了 co。koa2 改用了新的 async 编写，async 实现的功能本身就是 generator 加 co。你如果用非 async 函数，koa 内部会把它转换成一个 async 函数的。
- 函数前面加 async 的原因是因为函数里面用了 await，没用的话不加也行；
2. 返回 Promise 的函数前面加个 await 就能得到异步返回的结果，使用起来和同步一样（实际是异步）；
3. koa2 的特性就是用 async/await/Promise 代替以前的回调，使代码更简洁易懂；
以前那套回调，用 Promise 包装一下就可以拿来给 koa2 使用；
不用 async/await/Promise 还继续用回调函数的话，不如继续用 expressjs
https://leemove.github.io/2018/03/19/koa-compose/#more 这个就是 Koa 中间件的原理…看了这个应该就不会疑惑了…
我看过更详细的原理分析，就是看了才不明不为什么会安排成异步的，就是为什么 dispatch(i)要返回 promise 而不是普通函数或者对象，按照 middleware[]的顺序执行递归执行下去，应该可以达到洋葱模型吧？那这里的 promise 的意义是什么？
问题 2：promise 一个程度上可以使得异步更精准，也就是在失败成功都可以获得它的状态改变。promise 也有助于回调的扁平。使用 promise 的话，promise 链条状，可以使得外层中间件可以获得内层中间件的状态。在错误捕获上也是有优势.
以前版本的 co+generator+thunkify 约等于 async/await
问题 3：事实上如果你的下一个中间件或者当前代码是不需要异步操作的，比如直接是返回的一些硬编码，是不用 async await 的
在Node.js的Koa2框架中，中间件是异步的。Koa2的设计基于ES6的async/await语法，这使得处理异步操作变得更加直观和简洁。每个中间件都是一个async函数，可以依次处理请求和响应。
以下是一个简单的Koa2中间件示例，展示了中间件如何处理异步操作：
const Koa = require('koa');
const app = new Koa();
// 第一个中间件
app.use(async (ctx, next) => {
console.log('First Middleware Before');
await next(); // 等待下一个中间件执行
console.log('First Middleware After');
});
// 第二个中间件
app.use(async (ctx, next) => {
console.log('Second Middleware Before');
// 模拟异步操作，例如数据库查询
await new Promise(resolve => setTimeout(resolve, 1000));
console.log('Second Middleware After');
await next(); // 在这个例子中，没有下一个中间件，所以直接返回
});
app.use(async ctx => {
ctx.body = 'Hello World';
});
app.listen(3000, () => {
console.log('Server running on http://localhost:3000');
});
在这个例子中，当请求到达时，第一个中间件会首先记录日志，然后调用await next()，这会使控制权传递给下一个中间件。第二个中间件会模拟一个异步操作（例如数据库查询），然后同样调用await next()（尽管在这个例子中，没有更多的中间件来接收控制权）。最后，最后一个中间件设置响应体为Hello World。
因此，在Koa2中，中间件是异步的，这使得处理异步操作（如数据库查询、文件I/O等）变得更加方便。
