Promise.all() : lancer ensemble ce qui est réellement indépendant

Ce que vous saurez faire

Reconnaître ce qui est réellement indépendant, lancer plusieurs opérations ensemble sans perdre la gestion des erreurs, et limiter la concurrence quand la liste s’allonge.

Les exemples n’utilisent que des minuteurs : aucun serveur, aucune base de données. Ils se collent dans la console d’un navigateur, ou s’exécutent avec Node.js dans un module ECMAScript (fichier .mjs), car ils emploient await au niveau supérieur. Dans un fichier .js classique, enveloppez-les dans une fonction async. Les durées annoncées sont illustratives : elles servent à raisonner sur l’enchaînement, pas à mesurer une performance.

1. Créer la Promise, c’est déjà lancer le travail

Promise.all() ne lance rien. Ce sont les appels de fonction placés dans le tableau qui démarrent les opérations ; Promise.all() se contente d’attendre leur issue.

const tache = (nom, ms) =>
  new Promise((resolve) => setTimeout(() => resolve(nom), ms));

console.time('ensemble');
const resultats = await Promise.all([
  tache('a', 300),
  tache('b', 200),
  tache('c', 100),
]);
console.timeEnd('ensemble');
console.log(resultats);

Résultat attendu : une durée proche de la plus longue des trois attentes, et le tableau [ 'a', 'b', 'c' ]. Deux enseignements. D’abord, l’ordre du tableau de résultats suit celui des entrées, jamais l’ordre d’arrivée. Ensuite, si vous aviez écrit await tache('a', 300) avant de construire le tableau, les attentes auraient recommencé à s’additionner : tout le gain vient du moment où les opérations démarrent.

Référence : Promise.all().

2. Un rejet arrête l’attente, pas les opérations

Dès qu’une entrée rejette, Promise.all() rejette avec cette raison, sans attendre les autres. Mais les autres opérations, elles, continuent : rien ne les annule.

const echoue = (ms) =>
  new Promise((_, reject) => setTimeout(() => reject(new Error('KO')), ms));
const reussit = (ms) =>
  new Promise((resolve) => setTimeout(() => resolve('OK'), ms));

try {
  await Promise.all([echoue(100), reussit(500)]);
} catch (error) {
  console.error('échec global :', error.message);
}

Résultat attendu : le message d’échec apparaît vers cent millisecondes, alors que la seconde opération tourne encore et ne se terminera que vers cinq cents. Si cette seconde opération avait rejeté après le rejet global, personne n’aurait traité son rejet : c’est une cause classique de rejet non géré. Pour interrompre réellement une requête réseau, il faut un mécanisme d’annulation explicite, par exemple un AbortController passé à fetch().

3. Chaque combinateur répond à une question différente

Promise.allSettled() attend toutes les entrées et ne rejette pas : il renvoie un tableau décrivant chaque issue.

const issues = await Promise.allSettled([echoue(100), reussit(200)]);
console.log(issues);
// [ { status: 'rejected', reason: Error: KO },
//   { status: 'fulfilled', value: 'OK' } ]

C’est le bon choix quand un échec partiel reste acceptable : un tableau de bord peut afficher trois blocs sur quatre et signaler clairement le quatrième.

Deux autres combinateurs existent. Promise.any() renvoie la première entrée tenue et n’échoue que si toutes rejettent, ce qui convient pour interroger plusieurs sources équivalentes. Promise.race() renvoie la première issue quelle qu’elle soit, succès ou échec, et sert typiquement à imposer un délai maximal.

Référence : Promise.allSettled().

Pièges et limites

• Paralléliser une vraie dépendance. getOrders(user.id) a besoin de user. Aucun combinateur ne contourne cet enchaînement ; il faut deux attentes successives.
• Croire que Promise.all() annule. Le premier rejet libère l’attente ; les opérations déjà parties continuent, avec leurs effets et leurs éventuels rejets orphelins.
• Ouvrir cent mille opérations d’un coup. Promise.all(liste.map(envoyer)) sur une liste énorme sature la mémoire, le réseau ou le service distant. Traitez par lots, ou avec une limite de concurrence.
• Confondre parallélisme et concurrence. JavaScript n’exécute pas plusieurs morceaux de votre code au même instant : ce sont les attentes qui se recouvrent. Trois calculs synchrones lourds ne gagneront donc rien.

À vous de jouer

Vous devez envoyer un message à une liste d’identifiants, avec au maximum trois envois en cours simultanément, et connaître l’issue de chacun sans qu’un échec interrompe le reste. Écrivez cette fonction en n’utilisant que Promise.allSettled() et un découpage en lots. Simulez l’envoi par un minuteur qui rejette pour un identifiant donné, et vérifiez que les envois suivants ont bien lieu.

Correction commentée

const envoyer = (id) =>
  new Promise((resolve, reject) =>
    setTimeout(() => (id === 3 ? reject(new Error('id 3')) : resolve(id)), 100),
  );

async function envoyerParLots(ids, taille) {
  const issues = [];
  for (let i = 0; i < ids.length; i += taille) {
    const lot = ids.slice(i, i + taille);
    issues.push(...(await Promise.allSettled(lot.map(envoyer))));
  }
  return issues;
}

envoyerParLots([1, 2, 3, 4, 5], 3).then((issues) => console.log(issues));

Résultat attendu : cinq objets, dont un seul { status: 'rejected', reason: Error: id 3 }, les quatre autres portant status: 'fulfilled'.

Pourquoi c’est la bonne réponse. Le await dans la boucle est ici volontaire : il sépare les lots, et c’est précisément la limite de concurrence demandée. À l’intérieur d’un lot, lot.map(envoyer) lance les trois envois ensemble, car la Promise est créée au moment de l’appel. Promise.allSettled() garantit qu’un échec ne fait tomber ni le lot ni les lots suivants, et fournit l’issue de chaque envoi. Avec Promise.all(), le rejet de l’identifiant 3 aurait interrompu l’attente du deuxième lot et masqué les autres résultats, alors même que ces envois auraient bel et bien été effectués.