Правильный синтаксис TryCatch с использованием Async / Await

Кажется, лучше всего не помещать несколько строк бизнес-логики в тело попытки.

На самом деле я бы сказал, что это так. Обычно вы хотите, чтобы 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
}

Если вы хотите перехватывать и обрабатывать ошибки только из обещания, у вас есть три варианта:

• Объявите переменную снаружи и перейдите в зависимости от того, было исключение или нет. Это может принимать различные формы, например

  • assign a default value to the variable in the catch block
  • 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 (все еще) не поддерживает синтаксис для условные исключения.

  Если ваш метод не возвращает обещания, которые отклоняются с достаточно конкретными ошибками, вы можете сделать это самостоятельно, повторно добавив что-то более подходящее в обработчике .catch():

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

  См. Также Обработку нескольких захватов в цепочке обещаний для версии этого до _13 _ / _ 14_.

• Используйте then с двумя обратными вызовами вместо _16 _ / _ 17_. Это действительно наименее уродливый способ, и моя личная рекомендация также из-за его простоты и правильности, не полагаясь на помеченные ошибки или взгляды на значение результата, чтобы различать выполнение и отклонение обещания:

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

  Конечно, у этого есть недостаток, заключающийся в введении функций обратного вызова, то есть вы не можете так легко _19 _ / _ 20_ выполнять циклы или выполнять ранние return из внешней функции.

Другой более простой подход - добавить .catch к функции обещания. бывший:

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

Обычно я использую функцию catch() Promise для возврата объекта со свойством 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

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 можно найти в этот пост