Несколько объектов с отложенной передачей передаются в jQuery.when проблема [duplicate]

Подобный ответ, но более вероятно идиоматический для ES6:

const a = Promise.resolve(1);
const b = Promise.reject(new Error(2));
const c = Promise.resolve(3);

Promise.all([a, b, c].map(p => p.catch(e => e)))
  .then(results => console.log(results)) // 1,Error: 2,3
  .catch(e => console.log(e));


const console = { log: msg => div.innerHTML += msg + "<br>"};

<div id="div"></div>

В зависимости от типа (ов) возвращаемых значений , ошибки часто можно различить достаточно легко (например, используйте undefined для «не заботьтесь», typeof для простых значений без объекта, result.message, result.toString().startsWith("Error:") и т. д.)

Я просто написал пользовательскую функцию promise.all() и использовал ее вместо стандартного Promise.all(). Если все обещания разрешены, он выполняет точно так же, как и стандартный. Если одно из других обещаний отклонено, оно возвращает первое, которое отклонено так же, как и стандартное, но в отличие от него ждет всех обещаний разрешить / отклонить:

var promise = {};  // custom namespace for promise-related stuff

promise.all = function(values)
{
  var e;

  return Promise.all(values.map(function(value) {
    return Promise.resolve(value).catch(function(error) {
      e = e || error;
    });
  })).then(function(values2) {
    if(e)
      throw e;

    return values2;
  });
};

Мы можем пойти еще дальше, чтобы нежно расширьте стандарт Promise.all() одним дополнительным параметром wait следующим образом:

(function() {
  var stdAll = Promise.all;

  Promise.all = function(values, wait) {
    if(!wait)
      return stdAll.call(Promise, values);

    return promise.all(values);
  }
})();

Это может быть разумным, так как новая версия обратно совместима со стандартной, просто расширяя ее функциональность. (Мы можем полностью избежать пользовательского пространства имен promise - он используется для краткости, чтобы показать эту идею.)

Люди, которые разрабатывают стандарты - почему бы не включить это в новый стандарт Promise?

Я бы сделал:

var err = [fetch('index.html').then((success) => { return Promise.resolve(success); }).catch((e) => { return Promise.resolve(e); }),
fetch('http://does-not-exist').then((success) => { return Promise.resolve(success); }).catch((e) => { return Promise.resolve(e); })];

Promise.all(err)
.then(function (res) { console.log('success', res) })
.catch(function (err) { console.log('error', err) }) //never executed

Мой подход:

const promise1 = Promise.resolve(1)
const promise2 = Promise.reject(2)

const errors = []
Promise.all([
  promise1,
  promise2
].map((promise) => promise.catch((error) => {
  errors.push(error)
}))).then(([response1, response2]) => {
  console.log(response1)
  // 1
  console.log(response2)
  // undefined
  console.log(errors)
  // [2]
})

У него есть свои недостатки, но в целом он может быть эффективным. Я склонен использовать этот шаблон, когда меня не волнуют причины ошибок.

var err;
Promise.all([
    promiseOne().catch(function(error) { err = error;}),
    promiseTwo().catch(function(error) { err = error;})
]).then(function() {
    if (err) {
        throw err;
    }
});

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

Это должно соответствовать , как Q это :

if(!Promise.allSettled) {
    Promise.allSettled = function (promises) {
        return Promise.all(promises.map(p => Promise.resolve(p).then(v => ({
            state: 'fulfilled',
            value: v,
        }), r => ({
            state: 'rejected',
            reason: r,
        }))));
    };
}

Я не знаю, какую библиотеку обещаний вы используете, но у большинства есть что-то вроде allSettled .

Edit: Ok, так как вы хотите использовать простой ES6 без внешних библиотек, нет такого метода.

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

У меня была та же проблема, и я решил ее следующим образом:

const fetch = (url) => {
  return node-fetch(url)
    .then(result => result.json())
    .catch((e) => {
      return new Promise((resolve) => setTimeout(() => resolve(fetch(url)), timeout));
    });
};

tasks = [fetch(url1), fetch(url2) ....];

Promise.all(tasks).then(......)

В этом случае Promise.all будет ожидать, что каждое обещание войдет в состояние resolved или rejected.

И имея это решение, мы «останавливаем catch исполнение» неблокирующим способом. Фактически, мы ничего не останавливаем, мы просто возвращаем Promise в состояние ожидания, которое возвращает другой Promise, когда оно разрешено после таймаута.