Как правильно обрабатывать ошибки в цепочке Promise?

Ответ 1

У вас есть пара вариантов. Во-первых, давайте посмотрим, смогу ли я отменить ваши требования.

• Вы хотите обработать ошибку рядом с тем, где она встречается, поэтому у вас нет одного обработчика ошибок, который должен сортировать все возможные различные ошибки, чтобы увидеть, что делать.

• Когда одно обещание терпит неудачу, вы хотите иметь возможность прервать остальную цепочку.

Одна из возможностей такова:

A().then(passA).catch(failA).then(val => {
    return B(val).then(passB).catch(failB);
}).then(val => {
    return C(val).then(passC).catch(failC);
}).then(finalVal => {
    // chain done successfully here
}).catch(err => {
    // some error aborted the chain, may or may not need handling here
    // as error may have already been handled by earlier catch
});

Затем в каждом failA, failB, failC вы получите конкретную ошибку для этого шага. Если вы хотите прервать цепочку, вы снова свернете, прежде чем функция вернется. Если вы хотите, чтобы цепочка продолжалась, вы просто возвращаете нормальное значение.

Вышеприведенный код также можно записать следующим образом (при немного отличающемся поведении, если passB или passC выбрасывает или возвращает отклоненное обещание.

A().then(passA, failA).then(val => {
    return B(val).then(passB, failB);
}).then(val => {
    return C(val).then(passC, failC);
}).then(finalVal => {
    // chain done successfully here
}).catch(err => {
    // some error aborted the chain, may or may not need handling here
    // as error may have already been handled by earlier catch
});

Так как они полностью повторяются, вы можете заставить все это руководствоваться таблицей для любой длины последовательности.

function runSequence(data) {
    return data.reduce((p, item) => {
        return p.then(item[0]).then(item[1]).catch(item[2]);
    }, Promise.resolve());
}

let fns = [
    [A, passA, failA],
    [B, passB, failB],
    [C, passC, failC]
];

runSequence(fns).then(finalVal => {
    // whole sequence finished
}).catch(err => {
    // sequence aborted with an error
});

Еще один полезный момент при объединении множества promises - если вы создаете уникальный класс ошибок для каждой ошибки отклонения, тогда вы можете более легко включить тип ошибки с помощью instanceof в последнем обработчике .catch(), если вы нужно знать, какой шаг вызвал прерванную цепь. Библиотеки, такие как Bluebird, предоставляют определенную семантику .catch() для создания .catch(), которая улавливает только определенный тип ошибки (например, способ try/catch делает это). Вы можете видеть, как Bluebird делает это здесь: http://bluebirdjs.com/docs/api/catch.html. Если вы собираетесь обрабатывать каждую ошибку прямо в своем собственном отказе от обещания (как в приведенных выше примерах), тогда это не требуется, если вам еще не нужно знать на последнем этапе .catch(), на котором шаг вызвал ошибку.

Ответ 2

Есть два способа, которые я рекомендую (в зависимости от того, что вы пытаетесь сделать с этим):

Да, вы хотите обрабатывать все ошибки в цепочке обещаний с помощью одного catch.

Если вам нужно знать, какой из них не удалось, вы можете отклонить обещание с помощью уникального сообщения или значения, подобного этому:

A
.then(a => {
  if(!pass) return Promise.reject('A failed');
  ...
})
.then(b => {
  if(!pass) return Promise.reject('B failed');
  ...
})
.catch(err => {
  // handle the error
});

В качестве альтернативы вы можете вернуть другой promises внутри .then

A
.then(a => {
  return B; // B is a different promise
})
.then(b => {
  return C; // C is another promise
})
.then(c => {
  // all promises were resolved
  console.log("Success!") 
})
.catch(err => {
  // handle the error
  handleError(err)
});

В каждом из этих promises вам понадобится какое-то уникальное сообщение об ошибке, чтобы вы знали, какой из них не удалось.

И поскольку это функции стрелок, мы можем удалить фигурные скобки! Еще одна причина, по которой я люблю promises

A
.then(a => B)
.then(b => C)
.then(c => console.log("Success!"))
.catch(err => handleError(err));

Ответ 3

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

Всегда пропускайте ошибки и "обрабатывайте" их в точке, где возобновляется поток положительного кода.

Если вам нужно знать, как далеко все прошло, трюк, который я использую, - простой счетчик прогрессии:

let progress = "";
A()
.then(a => (progress = "A passed", passA(a)))
.then(B)
.then(b => (progress = "B passed", passB(b)))
.then(C)
.then(c => (progress = "C passed", passC(c)))
.catch(err => (console.log(progress), failAll(err)))