快速中间件中的异步/等待

Question

我很难理解如何在Express中正确编写使用async/await的中间件，但在执行后不会让Promise漂浮在以太网上。我已经阅读了大量的博客和StackOverflow帖子，似乎对于在async/await中间件中使用以下模式有一些共识：

const asyncHandler = fn => (req, res, next) =>
  Promise
    .resolve(fn(req, res, next))
    .catch(next)

app.use(asyncHandler(async (req, res, next) => {
  req.user = await User.findUser(req.body.id);
  next();
}));

我知道这使得在所有aysnc路由处理程序中不必使用try… catch逻辑成为可能，并且它确保（async（req， res， next）=返回的Promise

Promise
  .resolve(fn(req, res, next))
  .catch(next)

再也没有对返回的Promise调用then（）。使用此模式是因为我们不依赖中间件函数的任何返回值吗？只返回Promises而不调用then（）来获取它们的值，这样可以吗？因为Express中的中间件没有返回有意义的值？

我知道async/await允许我们处理异步代码并轻松处理返回的值，但在Express中间件中，我们只剩下顶级异步，它解析为Promise，然后我们用Promise.resolve（）解析，但它仍然解析为Promise…

此外，我知道这个问题有第三方解决方案，你可以使用另一个框架，如Koa。我只是想了解如何在Express中正确地做到这一点，因为我对Node后端开发仍然相对陌生，并且希望在了解基础知识之前只关注Express。

我的初步解决方案是仅在非中间件函数中使用异步/await，然后在实际中间件中返回的 Promise 上调用 then（），这样我就可以确定我没有做任何淘气的事情，就像这样：

app.use((req, res, next) => {
  User.findUser(req.body.id)
    .then(user => {
      req.user = user;
      next();
    })
    .catch(next)
});

这对我来说没什么，但是我一直看到到处都是asyncWrapper代码。我想多了，对吗？

Answer 1

您可以将 lib 用于此快速异步错误。它补丁快递没有问题。

Answer 2

你所做的绝对没问题。但是对于那些过度思考的人来说，有一个简单的解决方法。只需重写< code >异步处理程序。

const asyncHandler = fn => (req, res, next) => {
     fn(req, res, next)
     .catch(next);
}                                  
     

我们不需要使用Promise。asyncHandler上的resolve（）。因为fn是一个异步function，所以它返回一个promise。如果函数内部有错误，我们可以只使用catch（）来保证。

在这里，我们没有从asyncHandler函数返回任何东西，因为我们不需要这样做。

Answer 3

并且从不在这个返回的promise上调用then()。使用这种模式是因为我们不依赖中间件函数的任何返回值吗？

是否可以只返回Promises，而不调用that（）来获取它们的值，因为Express中的中间件没有返回有意义的值？

是的，如果您只想跟踪它是否被拒绝，因为它处理自己的成功完成，但您需要单独处理错误，那么您只需使用。catch（），这就是您正在做的事情。这很好。

如果我经常这样做，我要么切换到像Koa这样的promise友好框架，要么添加我自己的promise感知中间件注册。例如，Express的一个附加组件为您提供了支持promise的中间件：

// promise aware middleware registration
// supports optional path and 1 or more middleware functions
app.useP = function(...args) {
    function wrap(fn) {
        return async function(req, res, next) {
            // catch both synchronous exceptions and asynchronous rejections
            try {
                await fn(req, res, next);
            } catch(e) {
                next(e);
            }
        }
    }
    
    // reconstruct arguments with wrapped functions
    let newArgs = args.map(arg => {
        if (typeof arg === "function") {
            return wrap(arg);
        } else {
            return arg;
        }
    });
    // register actual middleware with wrapped functions
    app.use(...newArgs);
}

然后，要使用这个promise感知中间件注册，您只需像这样注册它:

app.useP(async (req, res, next) => {
  req.user = await User.findUser(req.body.id);
  next();
});

而且，任何被拒绝的promise都会自动为你处理。

这是一个更高级的实现。把它放在一个名为express-p.js的文件中：

const express = require('express');

// promise-aware handler substitute
function handleP(verb) {
    return function (...args) {
        function wrap(fn) {
            return async function(req, res, next) {
                // catch both synchronous exceptions and asynchronous rejections
                try {
                    await fn(req, res, next);
                } catch(e) {
                    next(e);
                }
            }
        }

        // reconstruct arguments with wrapped functions
        let newArgs = args.map(arg => {
            if (typeof arg === "function") {
                return wrap(arg);
            } else {
                return arg;
            }
        });
        // register actual middleware with wrapped functions
        this[verb](...newArgs);
    }
}

// modify prototypes for app and router
// to add useP, allP, getP, postP, optionsP, deleteP variants
["use", "all", "get", "post", "options", "delete"].forEach(verb => {
    let handler = handleP(verb);
    express.Router[verb + "P"] = handler;
    express.application[verb + "P"] = handler;
});

module.exports = express;

然后，在您的项目中，而不是这样：

const express = require('express');
app.get(somePath, someFunc);

使用此：

const express = require('./express-p.js');
app.getP(somePath, someFunc);

然后，您可以自由使用这些方法中的任何一种，它们会自动处理从routes返回的拒绝promise:

 .useP()
 .allP()
 .getP()
 .postP()
 .deleteP()
 .optionsP()

在您创建的应用程序对象或您创建的任何路由器对象上。此代码修改原型，因此您在加载此模块后创建的任何应用程序对象或路由器对象都将自动具有所有这些Promise-ware方法。