Мне сложно понять разницу между помещением .catchBEFORE и AFTER во вложенное обещание.

Альтернатива 1:

test1Async(10).then((res) => {
  return test2Async(22)
    .then((res) => {
      return test3Async(100);
    }).catch((err) => {
      throw "ERROR AFTER THEN";
    });
}).then((res) => {
  console.log(res);
}).catch((err) => {
  console.log(err);
});

Альтернатива 2:

test1Async(10).then((res) => {
   return test2Async(22)
     .catch((err) => {
        throw "ERROR BEFORE THEN";
      })
      .then((res) => {
        return test3Async(100);
      });
  }).then((res) => {
    console.log(res);
  }).catch((err) => {
    console.log(err);
  });

Поведение каждой функции следующее: test1 не работает, если число равно <0test2, если число равно, > 10и test3 не работает, если число нет 100. В этом случае test2 только терпит неудачу.

Я попытался запустить и сделать test2Async неуспешным, и BEFORE, и AFTER затем ведут себя одинаково, и это не выполняет test3Async. Может кто-нибудь объяснить мне главное отличие размещения улова в разных местах?

В каждой функции я console.log('Running test X')проверяю, выполняется ли она.

Этот вопрос возникает из-за предыдущей темы, которую я опубликовал. Как превратить вложенный обратный вызов в обещание? . Я полагаю, что это другая проблема и стоит опубликовать другую тему.

Итак, в основном вы спрашиваете, в чем разница между этими двумя (где pобещание, созданное из некоторого предыдущего кода):

return p.then(...).catch(...);

и

return p.catch(...).then(...);

Существуют различия, когда p разрешает или отклоняет, но значение этих различий зависит от того, что делает код внутри обработчиков .then()or .catch().

Что происходит при pразрешении:

В первой схеме при pразрешении .then()вызывается обработчик. Если этот .then()обработчик возвращает значение или другое обещание, которое в конечном итоге выполняется, .catch()обработчик пропускается. Но если .then()обработчик либо бросает, либо возвращает обещание, которое в конечном итоге отклоняет, тогда .catch()обработчик выполнит как отклонение в исходном обещании p, так и ошибку, которая возникает в .then()обработчике.

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

Итак, это отличие №1. Если .catch()обработчик AFTER, он также может перехватывать ошибки внутри .then()обработчика.

Что происходит при pбраке:

Теперь, в первой схеме, если обещание pотклоняется, то .then()обработчик пропускается, и .catch()обработчик будет вызван, как и следовало ожидать. То, что вы делаете в .catch()обработчике, определяет, что будет возвращено в качестве окончательного результата. Если вы просто возвращаете значение из .catch()обработчика или возвращаете обещание, которое в конечном итоге разрешается, тогда цепочка обещаний переходит в разрешенное состояние, потому что вы «обработали» ошибку и вернулись нормально. Если вы выбрасываете или возвращаете отклоненное обещание в .catch()обработчике, то возвращенное обещание остается отклоненным.

Во второй схеме, если промис pотклоняется, .catch()вызывается обработчик. Если вы возвращаете нормальное значение или обещание, которое в конечном итоге разрешается от .catch()обработчика (таким образом «обрабатывая» ошибку), то цепочка обещаний переключается в разрешенное состояние, и будет вызван .then()обработчик после .catch().

Итак, это различие №2. Если .catch()обработчик - BEFORE, он может обработать ошибку и разрешить .then()вызов обработчику.

Когда использовать:

Используйте первую схему, если вам нужен только один .catch()обработчик, который может перехватывать ошибки либо в исходном обещании, pлибо в .then()обработчике, и отклонение от pдолжно пропускать .then()обработчик.

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

Другой вариант

Есть еще один вариант использования обоих обратных вызовов, который вы можете передать, .then()как в:

 p.then(fn1, fn2)

Это гарантирует, что будет вызван только один из fn1или fn2. Если pразрешится, то fn1будет вызван. Если pоткажется, то fn2будет называться. Никакое изменение результата не fn1может заставить вас fn2ответить, или наоборот. Итак, если вы хотите быть абсолютно уверены, что вызывается только один из двух ваших обработчиков, независимо от того, что происходит в самих обработчиках, вы можете использовать p.then(fn1, fn2).

Ответ jfriend00 отличный, но я подумал, что было бы неплохо добавить аналогичный синхронный код.

return p.then(...).catch(...);

аналогичен синхронному:

try {
  iMightThrow() // like `p`
  then()
} catch (err) {
  handleCatch()
}

Если iMightThrow()не бросит, then()будет вызван. Если он бросает (или then()сам бросает), то handleCatch()будет вызван. Обратите внимание на то, что catchблок не контролирует, thenвызывается он или нет .

С другой стороны,

return p.catch(...).then(...);

аналогичен синхронному:

try {
  iMightThrow()
} catch (err) {
  handleCatch()
}

then()

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