Как правильно обрабатывать ошибки с помощью async / await

Question

Я пишу API, где у меня возникли небольшие проблемы с обработкой ошибок. Я не уверен, достаточно ли первого фрагмента кода или я должен смешать его с обещаниями, как во втором фрагменте кода. Любая помощь приветствуется!

try {
  var decoded = jwt.verify(req.params.token, config.keys.secret);
  var user = await models.user.findById(decoded.userId);
  user.active = true;
  await user.save();
  res.status(201).json({user, 'stuff': decoded.jti});
} catch (error) {
  next(error);
}

Второй фрагмент кода:

try {
      var decoded = jwt.verify(req.params.token, config.keys.secret);
      var user = models.user.findById(decoded.userId).then(() => {

      }).catch((error) => {

      });
      user.active = true;
      await user.save().then(() => {

      }).catch((error) => {

      })
      res.status(201).json({user, 'stuff': decoded.jti});
    } catch (error) {
      next(error);
    }

Answer 1

Я прочитал несколько статей, в которых предлагался блок try / catch для каждого запроса. Есть ли правда в этом?

Нет, это не обязательно. try/catch с await работает концептуально, как try/catch работает с обычными синхронными исключениями. Если вы просто хотите обрабатывать все ошибки в одном месте и хотите, чтобы весь ваш код просто прерывался одним обработчиком ошибок, независимо от того, где произошла ошибка, и вам не нужно перехватывать одну конкретную ошибку, чтобы вы могли сделать что-то особенное для этой конкретной ошибки, тогда один try/catch - это все, что вам нужно.

Но если вам нужно конкретно обработать одну конкретную ошибку, возможно, даже разрешив продолжить работу остальной части кода, тогда вам может понадобиться более локальный обработчик ошибок, который может быть локальным try/catch или .catch() на локальная асинхронная операция, которая возвращает обещание.

или я должен смешать его с обещаниями, как во втором фрагменте кода.

Формулировка этого говорит о том, что вы можете не совсем понять, что происходит с await, потому что обещания участвуют в обоих ваших кодовых блоках.

В обоих ваших кодовых блоках models.user.findById(decoded.userId); возвращает обещание. У вас есть два способа использовать это обещание.

1. Вы можете использовать await с ним, чтобы «приостановить» внутреннее выполнение функции, пока это обещание не разрешится или не отклонится.

2. Вы можете использовать .then() или .catch(), чтобы увидеть, когда обещание разрешается или отклоняется.

Оба используют обещание, возвращаемое из вашего models.user.findById(decoded.userId); вызова функции. Таким образом, вашу фразу было бы лучше сказать "или если бы я использовал локальный обработчик .catch() для конкретного обещания вместо того, чтобы перехватывать все отклонения в одном месте.

---

Делаем это:

// skip second async operation if there's an error in the first one
async function someFunc() {

    try {
        let a = await someFunc():
        let b = await someFunc2(a);
        return b + something;
    } catch(e) {
        return "";
    }
}

Аналогично соединению вашего обещания с одним обработчиком .catch() в конце:

// skip second async operation if there's an error in the first one
function someFunc() {
    return someFunc().then(someFunc2).catch(e => "");
}

Независимо от того, какая асинхронная функция отклоняет, применяется один и тот же обработчик ошибок. Если первый отклоняет, второй не выполняется, так как поток переходит непосредственно к обработчику ошибок. Это прекрасно, если вы хотите, чтобы поток шел, когда в первой асинхронной операции произошла ошибка.

Но предположим, что вы хотели, чтобы ошибка в первой функции была превращена в значение по умолчанию, чтобы всегда выполнялась вторая асинхронная операция. Тогда этот поток контроля не сможет этого достичь. Вместо этого вам нужно будет зафиксировать первую ошибку прямо в источнике, чтобы вы могли указать значение по умолчанию и продолжить обработку со второй асинхронной операцией:

// always run second async operation, supply default value if error in the first
async function someFunc() {

    let a;
    try {
        a = await someFunc():
    } catch(e) {
        a = myDefaultValue;
    }
    try {
        let b = await someFunc2(a);
        return b + something;
    } catch(e) {
        return "";
    }
}

Аналогично соединению вашего обещания с одним обработчиком .catch() в конце:

// always run second async operation, supply default value if error in the first
function someFunc() {
    return someFunc()
      .catch(err => myDefaultValue)
      .then(someFunc2)
      .catch(e => "");
}

Примечание: это пример, который никогда не отклоняет обещание, которое возвращает someFunc(), а скорее предоставляет значение по умолчанию (пустая строка в этом примере), а не отклоняет, чтобы показать вам различные способы обработки ошибок в этой функции. Это, конечно, не требуется. Во многих случаях просто возвращение отклоненного обещания является правильным, и этот абонент может решить, что делать с ошибкой отклонения.

Answer 2

Ответ таков: это зависит .

Поймайте каждую ошибку

Имеет смысл, если вы хотите реагировать по-разному на каждую ошибку.например:

 try {
        let decoded;
        try {
          decoded = jwt.verify(req.params.token, config.keys.secret);
        } catch (error) {
          return response
            .status(401)
            .json({ error: 'Unauthorized..' });
        }
...

Однако код может быть довольно запутанным, и вы захотите разделить обработку ошибок немного по-другому (например: выполните проверку JWT для некоторого предварительного запроса перехватывать и разрешать только действительные запросы к обработчикам и / или выполнять части findById и save в сервисе и запускать один раз за операцию).

Возможно, вы захотите выбросить 404, если ни один объект не был найден с данным идентификатором.

Поймать все сразу

Если вы хотите отреагировать в То же самое , если a) или b) или c) пойдет не так, то первый пример выглядит просто отлично.

  a) var decoded = jwt.verify(req.params.token, config.keys.secret);
  b) var user = await models.user.findById(decoded.userId);
  user.active = true;
  c) await user.save();
  res.status(201).json({user, 'stuff': decoded.jti});