最好的做法似乎是不要在 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（仍然）没有对条件异常的语法支持。

  如果您的方法没有返回因足够具体的错误而被拒绝的Promise，您可以通过在.catch()处理程序中重新抛出更合适的内容来自己做到这一点：

    try {
        const createdUser = await this.User.create(userInfo).catch(err => {
            throw new CreationError(err.message, {code: "USER_CREATE"});
        });
        …
    } …
  

  另请参阅处理Promise链中的多个捕获以了解此之前的async/await版本。

• then与两个回调一起使用，而不是try/ catch。这确实是最不丑陋的方式，我个人的建议也是因为它的简单性和正确性，不依赖标记的错误或结果值的外观来区分履行和拒绝Promise：

    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从外部函数执行 early s。

另一种更简单的方法是将 .catch 附加到 promise 函数。前任：

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

我通常使用 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);
}

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

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

然后按如下方式使用它：

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

@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”。

最后，您可以创建module“to.js”或简单地使用await-to-jsmodule。

你可以to在这篇文章中获得更多关于函数的信息