Javascript承诺解决困惑 私有RunMiddleware（路由：路由|例外路由，请求：HttpRequest，响应：HttpResponse）：承诺{ 返回新承诺（（解决、拒绝）=>{ 试一试{ route.middleware.forEach（异步（中间件：imidleware）=>{ log（“开始运行中间件”）； 等待中间件。进程（请求、响应）； log（'resolve run middleware'）； console.log（request.body）； }); log（'resolve all runmiddleware'）； 解决（）； }捕获（e）{ 拒绝（e）； } }); }

我已经编写了这个函数

runmiddleware

，当所有

middleware.process（）。我正在使用typescript
wait
功能，但它似乎不起作用。
我预计类似的事情会在
route.middleware.forEach（


“开始运行中间件”
然后等待解决
“解析运行中间件”

这对于
forEach
循环中的所有中间件都是如此，当列表全部完成时，然后才应该打印“resolve all RunMiddleware”，最后，
private RunMiddleware（…）
应该进行解析

但是，
forEach
现在得到了立即解决，从而阻止了所有中间件的完成

这应该如何处理？我认为
await
将在
forEach
循环中处理它，只有在
runmiddleware
的
resolve
最终才会被调用。
我在这里遗漏了什么？
因此，根据建议（），我写了如下

private runMiddlewares(route: Route | ExceptionRoute, request: HttpRequest, response: HttpResponse): Promise<any> {
    return new Promise((resolve, reject) => {
        try {
            route.middlewares.forEach(async (middleware: IMiddleware) => {
                console.log('begin run middleware');
                await middleware.process(request, response);
                console.log('resolve run middleware');
                console.log(request.body);
            });
            console.log('resolve all runMiddlewares');
            resolve();
        } catch (e) {
            reject(e);
        }
    });
}

私有RunMiddleware（路由：路由|例外路由，请求：HttpRequest，响应：HttpResponse）：承诺{
返回新承诺（异步（解析、拒绝）=>{
试一试{
const MiddlewarePromisery:any[]=[]；
route.middleware.forEach（（中间件：imidleware）=>{
log（“开始运行中间件”）；
push（中间件进程（请求、响应））；
//删除了forEach循环内部的wait用法，如下链接：https://cn.eslint.org/docs/3.0.0/rules/no-await-in-loop
//等待中间件。进程（请求、响应）；
//log（'resolve run middleware'）；
//console.log（request.body）；
});
等待承诺；
log（'resolve all runmiddleware'）；
解决（）；
}捕获（e）{
拒绝（e）；
}
});
}

我很乐意接受进一步的回答和建议/改进：）
您可以使用
map
从您的中间件创建一系列承诺。这个承诺数组可以交给
Promise.all
，当数组中的每个承诺都已解析时，它将解析

private runMiddlewares(route: Route | ExceptionRoute, request: HttpRequest, response: HttpResponse): Promise<any> {
    return new Promise(async (resolve, reject) => {
        try {
            const middlewarePromiseArry: any[] = [];
            route.middlewares.forEach((middleware: IMiddleware) => {
                console.log('begin run middleware');
                middlewarePromiseArry.push(middleware.process(request, response));
                // removed the use of await inside of forEach loop following this link: https://cn.eslint.org/docs/3.0.0/rules/no-await-in-loop
                // await middleware.process(request, response);
                // console.log('resolve run middleware');
                // console.log(request.body);
            });

            await Promise.all(middlewarePromiseArry);
            console.log('resolve all runMiddlewares');
            resolve();
        } catch (e) {
            reject(e);
        }
    });
}

或者更紧凑：

await Promise.all(route.middlewares.map((middleware: IMiddleware) => {
            console.log('begin run middleware');
            const promise = middleware.process(request, response);
            console.log('resolve run middleware');
            console.log(request.body);
            return promise
        });

问题可能是您正在
foreach
循环中使用
wait
。这也是一条eslint规则：它建议避免这种情况，并提供了另一种方法的示例谢谢，我也在猜测。我来自C的背景，它将在那里工作，所以我也希望它能在这里工作：）我用Pung.Engult编写它，它现在正在工作。@ VISHALAND可能考虑添加您的解决方案作为答案。如果显式共享，它可能会很有用。现在添加它。谢谢，只是好奇，这和我的答案有什么不同？另外，为什么映射函数中需要异步？实际上它非常类似（从控制流的角度来看）。我认为我的答案更容易理解，代码更少，更容易阅读。例如，你不需要为允诺创造一个允诺，你也不需要等待它，因为你无论如何都在回报一个允诺。通常鼓励使用Array.prototype.map，而不是从loops/forEach手动创建新数组
runMiddlewares(...) {
  return Promise.all(
    route.middlewares.map((middleware: IMiddleware) => {
      return middleware.process(request, response))
    })
  )
}