Promise.all - все или ничего. Он разрешается, как только разрешаются все обещания в массиве, или отклоняется, как только одно из них отклоняется. Другими словами, он либо разрешается с массивом всех разрешенных значений, либо отклоняется с единственной ошибкой.

В некоторых библиотеках есть что-то под названием Promise.when, которое, как я понимаю, вместо этого будет ждать, пока все обещания в массиве будут либо разрешены, либо отклонены, но я не знаком с этим, и его нет в ES6.

Ваш код

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

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

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

Promise.all(state.routes.map(function(route) {
  return route.handler.promiseHandler().catch(function(err) {
    return err;
  });
}))
.then(function(arrayOfValuesOrErrors) {
  // handling of my array containing values and/or errors. 
})
.catch(function(err) {
  console.log(err.message); // some coding error in handling happened
});

НОВЫЙ ОТВЕТ

const results = await Promise.all(promises.map(p => p.catch(e => e)));
const validResults = results.filter(result => !(result instanceof Error));

FUTURE Promise API

• Chrome 76: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/allSettled
• Вы можете загрузить https://www.npmjs.com/package/promise.allsettled, чтобы Получи это сейчас. В некоторых браузерах allSettled предустановлен вместе с самим браузером. Для спокойствия стоит скачать пакет, потому что, например. TypeScript не имеет определений по умолчанию для allSettled.

ES2020 представляет новый метод для типа Promise: Promise.allSettled().

Promise.allSettled дает вам сигнал, когда все входные обещания выполнены, что означает, что они либо выполнены, либо отклонены. Это полезно в тех случаях, когда вас не волнует состояние обещания, вы просто хотите знать, когда работа будет выполнена, независимо от того, была ли она успешной.

(async function() {
  const promises = [
    fetch('//api.stackexchange.com/2.2'), // succeeds
    fetch('/this-will-fail') // fails
  ];

  const result = await Promise.allSettled(promises);
  console.log(result.map(promise => promise.status));
  // ['fulfilled', 'rejected']
})();

Подробнее читайте в записи блога v8.

Чтобы продолжить цикл Promise.all (даже если Promise отклоняет), я написал служебную функцию, которая называется executeAllPromises. Эта служебная функция возвращает объект с results и errors.

Идея состоит в том, что все обещания, которые вы передаете executeAllPromises, будут заключены в новое обещание, которое всегда будет разрешаться. Новое обещание разрешается с помощью массива с двумя точками. Первая точка содержит значение разрешения (если есть), а вторая точка содержит ошибку (если завернутый Promise отклоняет).

В качестве последнего шага executeAllPromises накапливает все значения обернутых обещаний и возвращает окончательный объект с массивом для results и массивом для errors.

Вот код:

function executeAllPromises(promises) {
  // Wrap all Promises in a Promise that will always "resolve"
  var resolvingPromises = promises.map(function(promise) {
    return new Promise(function(resolve) {
      var payload = new Array(2);
      promise.then(function(result) {
          payload[0] = result;
        })
        .catch(function(error) {
          payload[1] = error;
        })
        .then(function() {
          /* 
           * The wrapped Promise returns an array:
           * The first position in the array holds the result (if any)
           * The second position in the array holds the error (if any)
           */
          resolve(payload);
        });
    });
  });

  var errors = [];
  var results = [];

  // Execute all wrapped Promises
  return Promise.all(resolvingPromises)
    .then(function(items) {
      items.forEach(function(payload) {
        if (payload[1]) {
          errors.push(payload[1]);
        } else {
          results.push(payload[0]);
        }
      });

      return {
        errors: errors,
        results: results
      };
    });
}

var myPromises = [
  Promise.resolve(1),
  Promise.resolve(2),
  Promise.reject(new Error('3')),
  Promise.resolve(4),
  Promise.reject(new Error('5'))
];

executeAllPromises(myPromises).then(function(items) {
  // Result
  var errors = items.errors.map(function(error) {
    return error.message
  }).join(',');
  var results = items.results.join(',');
  
  console.log(`Executed all ${myPromises.length} Promises:`);
  console.log(`— ${items.results.length} Promises were successful: ${results}`);
  console.log(`— ${items.errors.length} Promises failed: ${errors}`);
});

Как сказал @jib,

Promise.all - все или ничего.

Тем не менее, вы можете управлять определенными обещаниями, которым «разрешено» невыполнение, и мы хотели бы перейти к .then.

Например.

  Promise.all([
    doMustAsyncTask1,
    doMustAsyncTask2,
    doOptionalAsyncTask
    .catch(err => {
      if( /* err non-critical */) {
        return
      }
      // if critical then fail
      throw err
    })
  ])
  .then(([ mustRes1, mustRes2, optionalRes ]) => {
    // proceed to work with results
  })

Promise.allSettled

Вместо Promise.all используйте Promise.allSettled, который ожидает выполнения всех обещаний, независимо от результат

let p1 = new Promise(resolve => resolve("result1"));
let p2 = new Promise( (resolve,reject) => reject('some troubles') );
let p3 = new Promise(resolve => resolve("result3"));

// It returns info about each promise status and value
Promise.allSettled([p1,p2,p3]).then(result=> console.log(result));

Полифилл

if (!Promise.allSettled) {
  const rejectHandler = reason => ({ status: 'rejected', reason });
  const resolveHandler = value => ({ status: 'fulfilled', value });

  Promise.allSettled = function (promises) {
    const convertedPromises = promises
      .map(p => Promise.resolve(p).then(resolveHandler, rejectHandler));
    return Promise.all(convertedPromises);
  };
}

Использование Async await -

здесь одна асинхронная функция func1 возвращает разрешенное значение, а func2 выдает ошибку и возвращает нуль в этой ситуации, мы можем обрабатывать ее так, как мы хотим, и соответственно возвращать.

const callingFunction  = async () => {
    const manyPromises = await Promise.all([func1(), func2()]);
    console.log(manyPromises);
}


const func1 = async () => {
    return 'func1'
}

const func2 = async () => {
    try {
        let x;
        if (!x) throw "x value not present"
    } catch(err) {
       return null
    }
}

callingFunction();

Вывод - ['func1', null]

если вы используете q-библиотеку https://github.com/kriskowal/q, она имеет q. allSettled (), который может решить эту проблему, вы можете обрабатывать каждое обещание в зависимости от его состояния: полное или отклоненное, поэтому

existingPromiseChain = existingPromiseChain.then(function() {
var arrayOfPromises = state.routes.map(function(route){
  return route.handler.promiseHandler();
});
return q.allSettled(arrayOfPromises)
});

existingPromiseChain = existingPromiseChain.then(function(arrayResolved) {
//so here you have all your promises the fulfilled and the rejected ones
// you can check the state of each promise
arrayResolved.forEach(function(item){
   if(item.state === 'fulfilled'){ // 'rejected' for rejected promises
     //do somthing
   } else {
     // do something else
   }
})
// do stuff with my array of resolved promises, eventually ending with a res.send();
});

Для тех, кто использует ES8 и которые здесь спотыкаются, вы можете сделать что-то вроде следующего, используя асинхронные функции:

var arrayOfPromises = state.routes.map(async function(route){
  try {
    return await route.handler.promiseHandler();
  } catch(e) {
    // Do something to handle the error.
    // Errored promises will return whatever you return here (undefined if you don't return anything).
  }
});

var resolvedPromises = await Promise.all(arrayOfPromises);

Вы рассматривали Promise.prototype.finally()?

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

Из документации MDN:

Метод finally() может быть полезен, если вы хотите выполнить некоторую обработку или очистку после выполнения обещания, независимо от его результата.

Метод finally() очень похож на вызов .then(onFinally, onFinally), но есть несколько отличий:

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

Обратный вызов finally не получит никаких аргументов, поскольку нет надежных средств определения того, было ли обещание выполнено или отклонено. Этот вариант использования предназначен именно для тех случаев, когда вас не волнует причина отказа или ценность выполнения, и поэтому нет необходимости указывать ее.

В отличие от Promise.resolve(2).then(() => {}, () => {}) (который будет разрешен с помощью undefined), Promise.resolve(2).finally(() => {}) будет разрешен с помощью 2. Точно так же, в отличие от Promise.reject(3).then(() => {}, () => {}) (который будет выполнен с undefined), Promise.reject(3).finally(() => {}) будет отклонен с 3.

== Откат ==

Если ваша версия JavaScript не поддерживает Promise.prototype.finally(), вы можете использовать этот обходной путь из Джейка Арчибальда: Promise.all(promises.map(p => p.catch(() => undefined)));

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

Здесь я отклонил первое обещание, поэтому оно не определено, но мы можем использовать результат второго обещания, который имеет индекс 1.

const manyPromises = Promise.all([func1(), func2()]).then(result => {
    console.log(result[0]);  // undefined
    console.log(result[1]);  // func2
});

function func1() {
    return new Promise( (res, rej) => rej('func1')).catch(err => {
        console.log('error handled', err);
    });
}

function func2() {
    return new Promise( (res, rej) => setTimeout(() => res('func2'), 500) );
}

Promise.all поставил с фильтром

const promises = [
  fetch('/api-call-1'),
  fetch('/api-call-2'),
  fetch('/api-call-3'),
];
// Imagine some of these requests fail, and some succeed.

const resultFilter = (result, error) => result.filter(i => i.status === (!error ? 'fulfilled' : 'rejected')).map(i => (!error ? i.value : i.reason));

const result = await Promise.allSettled(promises);

const fulfilled = resultFilter(result); // all fulfilled results
const rejected = resultFilter(result, true); // all rejected results

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

function promiseNoReallyAll (promises) {
  return new Promise(
    async (resolve, reject) => {
      const failedPromises = []

      const successfulPromises = await Promise.all(
        promises.map(
          promise => promise.catch(error => {
            failedPromises.push(error)
          })
        )
      )

      if (failedPromises.length) {
        reject(failedPromises)
      } else {
        resolve(successfulPromises)
      }
    }
  )
}

Вы всегда можете обернуть свое обещание, возвращающее функции, таким образом, чтобы они перехватывали сбой и вместо этого возвращали согласованное значение (например, error.message), чтобы исключение не перекатывалось на функцию Promise.all и отключало ее.

async function resetCache(ip) {

    try {

        const response = await axios.get(`http://${ip}/resetcache`);
        return response;

    }catch (e) {

        return {status: 'failure', reason: 'e.message'};
    }

}

Я нашел способ (обходной путь) сделать это без синхронизации.

Итак, как было упомянуто ранее, Promise.all - это вообще ничего.

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

      let safePromises = originalPrmises.map((imageObject) => {
            return new Promise((resolve) => {
              // Do something error friendly
              promise.then(_res => resolve(res)).catch(_err => resolve(err))
            })
        })
    })

    // safe
    return Promise.all(safePromises)

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

try {
  let resArray = await Promise.all(
    state.routes.map(route => route.handler.promiseHandler().catch(e => e))
  );

  // in catch(e => e) you can transform your error to a type or object
  // that makes it easier for you to identify whats an error in resArray
  // e.g. if you expect your err objects to have e.type, you can filter
  // all errors in the array eg
  // let errResponse = resArray.filter(d => d && d.type === '<expected type>')
  // let notNullResponse = resArray.filter(d => d)

  } catch (err) {
    // code related errors
  }

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

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

const results = await Promise.all([
  this.props.client.query({
    query: GET_SPECIAL_DATES,
  }),
  this.props.client.query({
    query: GET_SPECIAL_DATE_TYPES,
  }),
  this.props.client.query({
    query: GET_ORDER_DATES,
  }),
]).catch(e=>console.log(e,"error"));
const specialDates = results[0].data.specialDates;
const specialDateTypes = results[1].data.specialDateTypes;
const orderDates = results[2].data.orders;

Вот как работает Promise.all. Если одно обещание reject(), весь метод немедленно терпит неудачу.

Есть варианты использования, в которых может потребоваться Promise.all, допускающий сбой обещаний. Чтобы это произошло, просто не используйте в своем обещании никаких reject() операторов. Однако, чтобы гарантировать, что ваше приложение / скрипт не зависнет в случае, если какое-либо одно базовое обещание никогда не получит ответа, вам необходимо установить для него тайм-аут.

function getThing(uid,branch){
    return new Promise(function (resolve, reject) {
        xhr.get().then(function(res) {
            if (res) {
                resolve(res);
            } 
            else {
                resolve(null);
            }
            setTimeout(function(){reject('timeout')},10000)
        }).catch(function(error) {
            resolve(null);
        });
    });
}

Я написал библиотеку npm, чтобы решить эту проблему красивее. https://github.com/wenshin/promiseallend

Установить

npm i --save promiseallend

2017-02-25 новый api, это не нарушает принципы обещания

const promiseAllEnd = require('promiseallend');

const promises = [Promise.resolve(1), Promise.reject('error'), Promise.resolve(2)];
const promisesObj = {k1: Promise.resolve(1), k2: Promise.reject('error'), k3: Promise.resolve(2)};

// input promises with array
promiseAllEnd(promises, {
    unhandledRejection(error, index) {
        // error is the original error which is 'error'.
        // index is the index of array, it's a number.
        console.log(error, index);
    }
})
    // will call, data is `[1, undefined, 2]`
    .then(data => console.log(data))
    // won't call
    .catch(error => console.log(error.detail))

// input promises with object
promiseAllEnd(promisesObj, {
    unhandledRejection(error, prop) {
        // error is the original error.
        // key is the property of object.
        console.log(error, prop);
    }
})
    // will call, data is `{k1: 1, k3: 2}`
    .then(data => console.log(data))
    // won't call
    .catch(error => console.log(error.detail))

// the same to `Promise.all`
promiseAllEnd(promises, {requireConfig: true})
    // will call, `error.detail` is 'error', `error.key` is number 1.
    .catch(error => console.log(error.detail))

// requireConfig is Array
promiseAllEnd(promises, {requireConfig: [false, true, false]})
    // won't call
    .then(data => console.log(data))
    // will call, `error.detail` is 'error', `error.key` is number 1.
    .catch(error => console.log(error.detail))

// requireConfig is Array
promiseAllEnd(promises, {requireConfig: [true, false, false]})
    // will call, data is `[1, undefined, 2]`.
    .then(data => console.log(data))
    // won't call
    .catch(error => console.log(error.detail))

————————————————————————————————

Старый плохой api, не используйте его!

let promiseAllEnd = require('promiseallend');

// input promises with array
promiseAllEnd([Promise.resolve(1), Promise.reject('error'), Promise.resolve(2)])
    .then(data => console.log(data)) // [1, undefined, 2]
    .catch(error => console.log(error.errorsByKey)) // {1: 'error'}

// input promises with object
promiseAllEnd({k1: Promise.resolve(1), k2: Promise.reject('error'), k3: Promise.resolve(2)})
    .then(data => console.log(data)) // {k1: 1, k3: 2}
    .catch(error => console.log(error.errorsByKey)) // {k2: 'error'}