Lors de l'utilisation de la promesse.tous les()?

Je ne suis pas sûr que quelqu'un a vraiment donné l'objectif plus général d'explication pour savoir quand utiliser Promise.all() (et quand ne pas l'utiliser):

Ce qui est(sont) le bon scénario(s) d'utilisation de la promesse.tous les()

Promise.all() est utile quand vous avez plus d'une promesse et votre code veut savoir quand toutes les opérations que ces promesses constituent ont terminé avec succès. Il n'a pas d'importance ce que la personne des opérations asynchrones. Si ils sont asynchrones, sont représentés par des promesses et votre code veut savoir quand ils ont tous terminé, puis Promise.all() est construit pour faire exactement cela.

Par exemple, supposons que vous avez besoin de recueillir des informations à partir de trois à distance les appels d'API et quand vous avez les résultats de tous les trois appels d'API, vous devez exécuter un code supplémentaire, en utilisant tous les trois résultats. Cette situation serait parfait pour Promise.all(). Vous pourriez donc quelque chose comme ceci:

Promise.all([apiRequest(...), apiRequest(...), apiRequest(...)]).then(function(results) {
    //API results in the results array here
    //processing can continue using the results of all three API requests
}, function(err) {
    //an error occurred, process the error here
});

Promise.all() est probablement les plus couramment utilisées avec les mêmes types de demandes (comme dans l'exemple ci-dessus), mais il n'y a pas de raison qu'il doit être. Si vous avez eu un autre cas où vous avez besoin de faire une demande d'API distante, lecture d'un fichier local et de lire un local de la sonde de température et puis, quand vous aviez des données provenant des trois opérations asynchrones, vous avez voulu puis faire un peu de traitement avec les données de tous les trois, vous souhaitez à nouveau utiliser Promise.all():

Promise.all([apiRequest(...), fs.readFileAsync(...), readTemperature(...)]).then(function(results) {
    //all results in the results array here
    //processing can continue using the results of all three async operations
}, function(err) {
    //an error occurred, process the error here
});

Sur le revers de la médaille, si vous n'avez pas besoin de se coordonner entre eux et, juste de la poignée de chaque opération asynchrone individuellement, alors vous n'avez pas besoin Promise.all(). Vous pouvez simplement le feu à chacune de vos opérations asynchrones avec leur propre .then() gestionnaires et aucune coordination entre eux est nécessaire.

En outre Promise.all() a ce qu'on appelle un "fast échec de la mise en œuvre". Elle renvoie d'un master promesse qui va rejeter dès que la première promesse que vous avez passé il rejette ou qu'il va résoudre lorsque toutes les promesses n'ont pas résolu. Donc, pour utiliser Promise.all() ce type de mise en œuvre doit travailler pour votre situation. Il existe d'autres situations où vous souhaitez exécuter plusieurs opérations asynchrones et vous avez besoin de tous les résultats, même si certains d'entre eux ont échoué. Promise.all() ne sera pas le faire pour vous. Au lieu de cela, vous utiliserez probablement quelque chose comme Promise.settle() de cette situation. Vous pouvez voir une mise en œuvre de .régler() ici qui vous donne accès à tous les résultats, même si certains n'. Ceci est particulièrement utile lorsque vous vous attendez à ce que certaines opérations peuvent échouer et vous avez une tâche utile à poursuivre, avec les résultats provenant de toutes les opérations réussi ou vous voulez examiner les raisons de défaillance pour toutes les opérations qui ont échoué à prendre des décisions sur cette base.

Sont là des pratiques exemplaires pour l'utilisation de la promesse.tous les()? Devrait-il être
idéalement utilisé uniquement si toutes les promesses sont les objets de la même ou de
types similaires?

Comme expliqué ci-dessus, il n'a pas d'importance ce que l'individu opérations asynchrones sont ou s'ils sont du même type. Il importe seulement de savoir si votre code doit les coordonner et de savoir quand ils tout réussir.

Il est également utile de faire la liste des situations où vous n'auriez pas utilisation Promise.all():

1. Lorsque vous avez seulement une opération asynchrone. Avec une seule opération, vous pouvez simplement utiliser un .then() gestionnaire d'une promesse et il n'y a aucune raison pour Promise.all().
2. Lorsque vous n'avez pas besoin de coordination entre les multiples opérations asynchrones.
3. Lorsqu'un rapide échec de la mise en œuvre n'est pas approprié. Si vous avez besoin de tous les résultats, même si certains échouent, Promise.all() ne sera pas le faire par lui-même. Vous voudrez probablement quelque chose comme Promise.settle() à la place.
4. Si vos opérations asynchrones ne sont pas tous de retour promesses, Promise.all() ne peut pas suivre une opération asynchrone qui n'est pas géré par une promesse.

OriginalL'auteur jfriend00

- Je utiliser promise.all() quand je dois faire des demandes pour mon API et je ne veux pas afficher quelque chose avant que l'application charge toutes les données demandées, j'ai donc retarder le flux d'exécution jusqu'à ce que j'ai toutes les données dont j'ai besoin.

Exemple:

Ce que je veux faire je veux charger les utilisateurs de mon application et de leurs produits (imaginez que vous avez à faire des demandes multiples) avant d'afficher un tableau dans mon application avec l'utilisateur e-mails et les noms de produit de chaque utilisateur.

Ce que je vais faire - je envoyer les demandes à mon API de la création de l'promesses et à l'aide de promise.all()

Ce que je fais lorsque toutes les données ont été chargées une Fois que les données arrivent sur mon application, je peux exécuter la fonction de rappel de promises.all() et ensuite faire voir la table avec les utilisateurs.

J'espère que cela vous aidera à voir dans le scénario qui a du sens pour utiliser promises.all()

OriginalL'auteur miquelarranz

J'ai tendance à utiliser promesse à tous pour quelque chose comme ceci:

myService.getUsers()
   .then(users => {
       this.users = users;

       var profileRequests = users.map(user => {
           return myService.getProfile(user.Id); //returns a promise
       });

       return Promise.all(profileRequests);
   })
   .then(userProfilesRequest => {
       //do something here with all the user profiles, like assign them back to the users.

       this.users.forEach((user, index) => {
           user.profile = userProfilesRequest[index];
       });
   });

Ici, pour chaque utilisateur, nous allons off d'accéder à leur profil. Je ne veux pas que ma promesse de la chaîne de sortir de la main, maintenant que j'ai x montant des promesses de résoudre.

Donc Promise.all() va regrouper tous mes promesses de retour dans un, et je peux gérer que par le biais de la prochaine then. Je peux continuer à faire cela pour aussi longtemps qu'un, comme, par exemple, pour chaque profil, je veux obtenir les paramètres relatifs etc. etc. Chaque fois que je créer des tonnes de nouvelles promesses, je peux les regrouper tous dans un.

OriginalL'auteur Callum Linington

Promise.all passe un tableau de valeurs à partir de toutes les promesses dans l'itérable objet qu'elle a été adoptée.

https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Promise/all

var isCallFailed = false;
function myEndpoint1() {
  return isCallFailed ? Promise.reject("Bohoo!") :Promise.resolve({"a":"a"});
}
function myEndpoint2() {
  return Promise.resolve({"b":"b"});
}

Promise.all([myEndpoint1(), myEndpoint2()])
.then(values => {
  var data1 = values[0];
  var data2 = values[1];
  alert("SUCCESS... data1: " + JSON.stringify(data1) + "; data2: " +  JSON.stringify(data2));
})
.catch(error => {
  alert("ERROR... " + error);
});

vous pouvez essayer une autre affaire en faisant isCallFailed = true.

OriginalL'auteur Venky