如何在不使用 try catch 块的情况下处理多个异步等待中的错误，而 promise 被拒绝？

Question

我是新来表达的，正在制作用户注册 api。在这个我需要散列用户密码并生成一个随机字符串。这两件事都是由 aync/await 完成的。如果一个承诺被拒绝，那么它会在错误处理中返回响应，但会向我显示未处理的拒绝承诺的警告。

methods.signup = async (req,res,next) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
        return res.status(config.errorCodes.validation).json({errors:errors.array()});
    }
    let payload = req.body;
    var newUser = new User({
        username:payload.username,
        fullname:payload.fullname,
        email: payload.email,
        password: payload.password,
        urltoken:{
            token:null
        },
        actStatus: 0,
        provider: 'email',
       role:1
    });
    let hash = commonMethods.generatePasswordHash(payload.password);
    let token = commonMethods.createRandomString();

    let [a,b] = await Promise.all([hash,token]).catch(err=>{
        res.status(400).json({status:false,msg:"error in promise"})
     });

    newUser.password = a;
    newUser.urltoken.token = b;
    newUser.save(function(err){
        if(err) {
            return res.status(config.errorCodes.success).json({ status:false 
        ,msg:"Error in saving userdata. Please try again",err});
        }
        else {
            commonMethods.sendMail(newUser);
            return res.status(config.errorCodes.success).json({"status":true, 
        "msg":"Registered succesfully. Please Check your Email to verify 
        your account.",newUser})
    }
}); 
}

承诺是 -

commonMethods.createRandomString = function(password){
    return new Promise(function(resolve, reject) {
    var chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXTZabcdefghiklmnopqrstuvwxyz";
    var string_length = 25;
    var randomstring = '';
    for (var i=0; i<string_length; i++) {
        var rnum = Math.floor(Math.random() * chars.length);
        randomstring += chars.substring(rnum,rnum+1);
    }
   reject(randomstring);
   // resolve(randomstring);

})
}

总是因为创建错误而被拒绝。

这里是下面的错误

UnhandledPromiseRejectionWarning: Unhandled promise rejection. This error originated either by throwing inside of an async function without a catch block, or by rejecting a promise which was not handled with .catch(). (rejection id: 2)
(node:15172) [DEP0018] DeprecationWarning: Unhandled promise rejections are deprecated. In the future, promise rejections that are not handled will terminate the Node.js process with a non-zero exit code.

如何在不使用 try catch 或 then for promises 的情况下捕获这些错误并保持我的代码简单易读。

Answer 1

问题是线条

let [a,b] = await Promise.all([hash,token]).catch(err=>{
  res.status(400).json({status:false,msg:"error in promise"})
});

如果hash 或token 抛出，则进入.catch 函数，但catch 函数不返回任何内容：因此，在await 和catch 完成后，解释器会看到类似

let [a,b] = undefined

这不起作用（undefined 不可迭代），所以整个 .signup 方法拒绝。如果hash 或token 中出现错误，您需要一些方法让signup 函数的其余部分停止执行，可能类似于

const result = await Promise.all([hash,token]).catch(err=>{
  res.status(400).json({status:false,msg:"error in promise"})
});
if (!result) return;
let [a,b] = result;

你说你不想使用try/catch，但是这样逻辑可能更容易遵循，因为你可以立即从catch内部return：

let a, b;
try {
  ([a, b] = await Promise.all([hash,token]));
} catch(e) {
  return res.status(400).json({status:false,msg:"error in promise"});
}

Answer 2

API 编码约定建议

1) 有两种方法可以巧妙地处理错误。第一个是使用 try catch 块包装所有异步路由，该块将处理同步和异步代码错误。

异步/等待

methods.foo = async(req, res, next) => {
try {
    // assuming bizz is a utility analogous to createRandomString
    // and returns a promise object which will either get resolved or rejected
    // if resolved the response will end in this case and end the response
    // if rejected, await will throw an error which will be caught by the catch block
    var bar = await bizz(); // Asynchronous code(which will wait for a promise to be resolved)

    // {... DO SYNCHRONOUS STUFF ...}

    // if suppose there is an error in your synchronous code,
    // then it will throw an error which also will  be caught by the catch block
    res.end();
} catch (err) {
    // {... DO WHAT YOU NEED TO WITH THE ERROR CAUGHT BY EITHER Asynchronous OR Synchronous part of the method ...}
    console.log(err);
    res.end(err);
  }
}

2) 第二种方法是使用一个中间件来包装所有路由，从而避免为所有路由重写 try catch。这里同步和异步错误都将由异步中间件中的 .catch() 部分处理。

使用异步等待中间件

const asyncMiddleware = (asyncFunction) => {
return (req, res, next) => {
    Promise.resolve(asyncFunction(req, res, next))
    .catch((err) => {
        // DO STUFF WITH ERROR
        res.end(err);
    });
  }
};
methods.foo = asyncMiddleware((req, res, next) => {
  // assuming bizz is a utility analogous to createRandomString
  // and returns a promise object which will either get resolved or rejected
  // if resolved the response will end in this case and end the response
  // if rejected, await will throw an error which will be caught by asyncMiddleware
  var bar = await bizz(); // Asynchronous code(which will wait for a promise to be resolved)

  // {... DO SYNCHRONOUS STUFF ...}
  // if suppose there is an error in your synchronous code
  // then it will throw an error which also will be caught by asyncMiddleware
  res.end();
});