Gestion des erreurs dans Promise.all

J'ai un éventail de promesses avec lesquelles je résous Promise.all(arrayOfPromises);

Je continue la chaîne de promesses. Ressemble à quelque chose comme ça

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

existingPromiseChain = existingPromiseChain.then(function(arrayResolved) {
  // do stuff with my array of resolved promises, eventually ending with a res.send();
});

Je veux ajouter une instruction catch pour gérer une promesse individuelle en cas d'erreur, mais lorsque j'essaie, Promise.allrenvoie la première erreur trouvée (ignore le reste), puis je ne peux pas obtenir les données du reste des promesses dans le tableau (qui n'a pas fait d'erreur).

J'ai essayé de faire quelque chose comme ..

existingPromiseChain = existingPromiseChain.then(function() {
      var arrayOfPromises = state.routes.map(function(route){
        return route.handler.promiseHandler()
          .then(function(data) {
             return data;
          })
          .catch(function(err) {
             return err
          });
      });
      return Promise.all(arrayOfPromises)
    });

existingPromiseChain = existingPromiseChain.then(function(arrayResolved) {
      // do stuff with my array of resolved promises, eventually ending with a res.send();
});

Mais cela ne résout pas.

Merci!

-

Éditer:

Ce que les réponses ci-dessous ont dit était complètement vrai, le code cassait pour d'autres raisons. Si quelqu'un est intéressé, c'est la solution avec laquelle je me suis retrouvé ...

Chaîne de serveurs Node Express

serverSidePromiseChain
    .then(function(AppRouter) {
        var arrayOfPromises = state.routes.map(function(route) {
            return route.async();
        });
        Promise.all(arrayOfPromises)
            .catch(function(err) {
                // log that I have an error, return the entire array;
                console.log('A promise failed to resolve', err);
                return arrayOfPromises;
            })
            .then(function(arrayOfPromises) {
                // full array of resolved promises;
            })
    };

Appel API (appel route.async)

return async()
    .then(function(result) {
        // dispatch a success
        return result;
    })
    .catch(function(err) {
        // dispatch a failure and throw error
        throw err;
    });

Mettre le .catchfor Promise.allavant le .thensemble avoir permis de détecter les erreurs des promesses originales, mais de renvoyer ensuite l'ensemble du tableau au suivant.then

Merci!

Promise.allc'est tout ou rien. Il résout une fois que toutes les promesses du tableau sont résolues, ou rejetées dès que l' une d'elles rejette. En d'autres termes, il résout soit avec un tableau de toutes les valeurs résolues, soit il rejette avec une seule erreur.

Certaines bibliothèques ont quelque chose appelé Promise.when, qui, à ma connaissance, attendrait toutes les promesses du tableau à résoudre ou à rejeter, mais je ne le connais pas et ce n'est pas dans ES6.

Votre code

Je suis d'accord avec les autres ici que votre solution devrait fonctionner. Il doit être résolu avec un tableau qui peut contenir un mélange de valeurs réussies et d'objets erreurs. Il est inhabituel de passer des objets d'erreur dans le chemin de réussite, mais en supposant que votre code les attend, je ne vois aucun problème avec cela.

La seule raison pour laquelle je peux penser pourquoi cela "ne résoudrait pas" est qu'il échoue dans le code que vous ne nous montrez pas et que vous ne voyez aucun message d'erreur à ce sujet parce que cette chaîne de promesses n'est pas terminée par un final attraper (autant que ce que vous nous montrez de toute façon).

J'ai pris la liberté de factoriser la "chaîne existante" de votre exemple et de terminer la chaîne avec un crochet. Cela ne vous convient peut-être pas, mais pour les personnes qui lisent ceci, il est important de toujours renvoyer ou terminer les chaînes, sinon les erreurs potentielles, même les erreurs de codage, seront masquées (ce qui, je suppose, s'est produit ici):

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
});

NOUVELLE RÉPONSE

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

API FUTURE Promise

• Chrome 76: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/allSettled
• Vous pouvez télécharger https://www.npmjs.com/package/promise.allsettled pour l'obtenir maintenant. Dans certains navigateurs, allSettled est préinstallé avec le navigateur lui-même. Cela vaut la peine de télécharger le package pour la tranquillité d'esprit car par exemple. TypeScript n'a pas de définitions par défaut pour allSettled.

Pour continuer la Promise.allboucle (même lorsqu'une promesse refuse), j'ai écrit une fonction utilitaire qui est appelée executeAllPromises. Cette fonction utilitaire renvoie un objet avec resultset errors.

L'idée est que toutes les promesses auxquelles vous passez executeAllPromisesseront enveloppées dans une nouvelle promesse qui sera toujours résolue. La nouvelle promesse se résout avec un tableau qui a 2 spots. Le premier emplacement contient la valeur de résolution (le cas échéant) et le second emplacement conserve l'erreur (si la promesse encapsulée rejette).

Comme étape finale, le executeAllPromisesaccumule toutes les valeurs des promesses encapsulées et retourne l'objet final avec un tableau pour resultset un tableau pour errors.

Voici le code:

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}`);
});

ES2020 introduit une nouvelle méthode pour le type de promesse: Promise.allSettled()
Promise.allSettled vous donne un signal lorsque toutes les promesses d'entrée sont réglées, ce qui signifie qu'elles sont remplies ou rejetées. Ceci est utile dans les cas où vous ne vous souciez pas de l'état de la promesse, vous voulez simplement savoir quand le travail est terminé, qu'il ait réussi ou non.

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

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

En savoir plus dans le blog v8 https://v8.dev/features/promise-combinators

Comme l'a dit @jib,

Promise.all c'est tout ou rien.

Cependant, vous pouvez contrôler certaines promesses qui sont "autorisées" à échouer et nous aimerions continuer .then.

Par exemple.

  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
  })

si vous arrivez à utiliser la bibliothèque q https://github.com/kriskowal/q, elle dispose de la méthode q.allSettled () qui peut résoudre ce problème, vous pouvez gérer chaque promesse en fonction de son état soit complet, soit rejeté, donc

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();
});

Utilisation d'Async wait -

ici, une fonction asynchrone func1 renvoie une valeur résolue, et func2 renvoie une erreur et renvoie une valeur nulle dans cette situation, nous pouvons la gérer comme nous le voulons et retourner en conséquence.

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();

La sortie est - ['func1', null]

Pour ceux qui utilisent ES8 qui trébuchent ici, vous pouvez faire quelque chose comme ceci, en utilisant des fonctions asynchrones :

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);

Nous pouvons gérer le rejet au niveau des promesses individuelles, donc lorsque nous obtenons les résultats dans notre tableau de résultats, l'index du tableau qui a été rejeté sera undefined . Nous pouvons gérer cette situation au besoin et utiliser les résultats restants.

Ici, j'ai rejeté la première promesse, elle est donc indéfinie, mais nous pouvons utiliser le résultat de la deuxième promesse, qui est à l'index 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) );
}

Avez-vous réfléchi Promise.prototype.finally()?

Il semble être conçu pour faire exactement ce que vous voulez - exécuter une fonction une fois que toutes les promesses ont été réglées (résolues / rejetées), indépendamment de certaines des promesses rejetées.

De la documentation MDN :

La finally()méthode peut être utile si vous souhaitez effectuer un traitement ou un nettoyage une fois la promesse réglée, quel que soit son résultat.

La finally()méthode est très similaire à l'appel, .then(onFinally, onFinally)mais il existe quelques différences:

Lors de la création d'une fonction en ligne, vous pouvez la transmettre une fois, au lieu d'être obligé de la déclarer deux fois ou de créer une variable pour elle.

Un rappel final ne recevra aucun argument, car il n'existe aucun moyen fiable de déterminer si la promesse a été tenue ou rejetée. Ce cas d'utilisation est précisément lorsque vous ne vous souciez pas de la raison du rejet ou de la valeur de réalisation, et il n'est donc pas nécessaire de le fournir.

Contrairement à Promise.resolve(2).then(() => {}, () => {})(qui sera résolu avec undefined), Promise.resolve(2).finally(() => {})sera résolu avec 2. De même, contrairement à Promise.reject(3).then(() => {}, () => {})(qui sera rempli avec undefined), Promise.reject(3).finally(() => {})sera rejeté avec 3.

== Repli ==

Si votre version de JavaScript ne prend pas en charge, Promise.prototype.finally()vous pouvez utiliser cette solution de contournement de Jake Archibald :Promise.all(promises.map(p => p.catch(() => undefined)));

Alternativement, si vous avez un cas où vous ne vous souciez pas particulièrement des valeurs des promesses résolues quand il y a un échec mais que vous voulez toujours qu'elles se soient déroulées, vous pouvez faire quelque chose comme ça qui résoudra les promesses normalement lorsque ils réussissent tous et rejettent avec les promesses manquées quand l'un d'eux échoue:

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)
      }
    }
  )
}

Vous pouvez toujours envelopper vos fonctions de retour de promesse d'une manière qui attrape l'échec et renvoie à la place une valeur convenue (par exemple error.message), de sorte que l'exception ne sera pas transférée jusqu'à la fonction Promise.all et la désactiver.

async function resetCache(ip) {

    try {

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

    }catch (e) {

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

}

J'ai trouvé un moyen (solution de contournement) de le faire sans le synchroniser.

Donc, comme cela a été mentionné précédemment Promise.all tout est nul.

alors ... Utilisez une promesse englobante pour attraper et forcer la résolution.

      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)

Vous devez savoir comment identifier une erreur dans vos résultats. Si vous n'avez pas d'erreur standard attendue, je vous suggère d'exécuter une transformation sur chaque erreur dans le bloc catch qui la rend identifiable dans vos résultats.

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
  }

Ce n'est pas le meilleur moyen de consigner les erreurs, mais vous pouvez toujours tout définir sur un tableau pour promiseAll et stocker les résultats résultants dans de nouvelles variables.

Si vous utilisez graphQL, vous devez malgré tout post-traiter la réponse et si elle ne trouve pas la référence correcte, l'application se bloquera, ce qui réduira l'emplacement du problème.

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;

Voilà comment Promise.allest conçu pour fonctionner. Si une seule promesse est faite reject(), la méthode entière échoue immédiatement.

Il existe des cas d'utilisation où l'on peut souhaiter que les Promise.allpromesses échouent. Pour ce faire, n'utilisez simplement aucune reject()déclaration dans votre promesse. Cependant, pour vous assurer que votre application / script ne se fige pas au cas où une seule promesse sous-jacente n'obtiendrait jamais de réponse, vous devez y mettre un délai d'attente.

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);
        });
    });
}

J'ai écrit une bibliothèque npm pour faire face à ce problème plus beau. https://github.com/wenshin/promiseallend

Installer

npm i --save promiseallend

2017-02-25 nouvelle API, ce n'est pas rompre les principes de la promesse

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))

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

Vieille mauvaise api, ne l'utilisez pas!

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'}