使用Async / Await正确尝试…捕获语法

let createdUser
try {
    createdUser = await this.User.create(userInfo)
} catch (error) {
    console.error(error)
}

console.log(createdUser)
// business
// logic
// goes
// here

#1 楼

最好的做法是不要在try主体中放置多行业务逻辑。


实际上我会这样说。通常，您希望使用值使用catch所有异常：

try {
    const createdUser = await this.User.create(userInfo);

    console.log(createdUser)
    // business logic goes here
} catch (error) {
    console.error(error) // from creation or business logic
}

如果您只想捕获并处理来自promise的错误，则有以下三种选择：



在外部声明变量，并根据是否存在异常进行分支。可以采用各种形式，例如


在catch块中为变量分配默认值

return提前或重新throw来自catch块的异常
设置catch块是否捕获到异常的标志，并在if条件下对其进行测试
测试要分配的变量的值

let createdUser; // or use `var` inside the block
try {
    createdUser = await this.User.create(userInfo);
} catch (error) {
    console.error(error) // from creation
}
if (createdUser) { // user was successfully created
    console.log(createdUser)
    // business logic goes here
}

测试捕获到的异常的类型，并根据该异常进行处理或重新抛出。

try {
    const createdUser = await this.User.create(userInfo);
    // user was successfully created
    console.log(createdUser)
    // business logic goes here
} catch (error) {
    if (error instanceof CreationError) {
        console.error(error) // from creation
    } else {
        throw error;
    }
}

不幸的是，标准JavaScript（仍然）不支持条件异常的语法。


将then与两个回调一起使用，而不是try / catch。这确实是最丑陋的方式，我个人的建议还出于其简单性和正确性，而不是依靠标记的错误或结果值的外观来区分承诺的履行与否：

await this.User.create(userInfo).then(createdUser => {
    // user was successfully created
    console.log(createdUser)
    // business logic goes here
}, error => {
    console.error(error) // from creation
});

当然，它带有引入回调函数的缺点，这意味着您不能轻易地通过外部函数轻松地进行break / continue循环或执行早期的return。

#2 楼

另一种更简单的方法是将.catch追加到promise函数。例如：

const createdUser = await this.User.create(userInfo).catch( error => {
// handle error
})

#3 楼

我通常会在失败时使用Promise的catch()函数返回具有error属性的对象。例如，在您的情况下，我会这样做：

 const createdUser = await this.User.create(userInfo)
          .catch(error => { error }); // <--- the added catch

if (Object(createdUser).error) {
    console.error(error)
}
 

如果您不想继续添加catch()调用，则可以在该函数的原型中添加一个辅助函数：

 Function.prototype.withCatcher = function withCatcher() {
    const result = this.apply(this, arguments);
    if (!Object(result).catch) {
        throw `${this.name}() must return a Promise when using withCatcher()`;
    }
    return result.catch(error => ({ error }));
};
 

现在您可以执行以下操作：

 const createdUser = await this.User.create.withCatcher(userInfo);
if (Object(createdUser).error) {
    console.error(createdUser.error);
}
 

编辑03/2020

您还可以添加默认的“捕获到错误对象”函数，如下所示：

 Promise 

然后如下使用它：

 Promise.prototype.catchToObj = function catchToObj() {
    return this.catch(error => ({ error }));
};
 

#4 楼

@Bergi答案很好，但是我认为这不是最好的方法，因为您必须回到旧的then（）方法，所以我认为更好的方法是捕获异步函数中的错误

async function someAsyncFunction(){
    const createdUser = await this.User.create(userInfo);

    console.log(createdUser)
}

someAsyncFunction().catch(console.log);

但是如果我们在同一函数中有许多await并需要捕获每个错误怎么办？

您可以声明to()函数

function to(promise) {
    return promise.then(data => {
        return [null, data];
    })
    .catch(err => [err]);
}

然后

async function someAsyncFunction(){
    let err, createdUser, anotherUser;

    [err, createdUser] = await to(this.User.create(userInfo));

    if (err) console.log(`Error is ${err}`);
    else console.log(`createdUser is ${createdUser}`);


    [err, anotherUser] = await to(this.User.create(anotherUserInfo));

    if (err) console.log(`Error is ${err}`);
    else console.log(`anotherUser is ${anotherUser}`);
}

someAsyncFunction();

阅读此内容时：“等待this.User.create” 。


最后，您可以创建模块“ to.js”，也可以简单地使用await-to-js模块。

您可以获得有关to的更多信息这篇文章中的功能