Exécution séquentielle de promesses avec passage de paramètres à partir d'un tableau

Considérez le scénario dans lequel vous disposez d'un tableau de valeurs (par exemple, myArray) et devez exécuter une promesse- fonction basée sur (par exemple, myPromise) séquentiellement, en passant chaque élément du tableau en tant que paramètre. Comment pouvez-vous implémenter une « boucle pauseable » qui garantit que les promesses sont résolues dans le bon ordre ?

Solution : exécution itérative des promesses

Pour obtenir une exécution séquentielle, vous pouvez utiliser une combinaison d'enchaînement de promesses et le traitement itératif. Voici un extrait de code démontrant comment cela peut être réalisé :

myArray.reduce(
  (p, x) =>
    p.then(() => myPromise(x)),
  Promise.resolve()
)

Cette approche exploite la méthode de réduction pour parcourir le tableau et créer une série de promesses enchaînées. Chaque promesse est résolue une fois la promesse précédente terminée, appliquant ainsi la séquence d'exécution souhaitée.

Alternative aux fonctions asynchrones

Si vous prenez en charge les fonctions asynchrones, une solution plus propre est disponible en utilisant forEachSeries function:

const forEachSeries = async (iterable, action) => {
  for (const x of iterable) {
    await action(x)
  }
}

forEachSeries(myArray, myPromise)

Cette fonction parcourt le tableau et s'arrête à chaque élément, en attendant que la promesse soit résolue avant de passer à l'itération suivante.

Collecte des résultats

Si vous devez collecter les valeurs de retour des promesses dans un tableau, vous pouvez modifier la fonction forEachSeries comme suit :

const mapSeries = async (iterable, fn) => {
  const results = []

  for (const x of iterable) {
    results.push(await fn(x))
  }

  return results
}

Cette fonction parcourt le tableau, accumule les résultats des promesses dans le tableau de résultats et renvoie finalement les résultats collectés.