Comment exécuter de manière synchrone une séquence de promesses en JavaScript ?

Comment synchroniser une séquence de promesses ?

Dans ce scénario, nous avons un tableau d'objets de promesse qui doivent être résolus dans l'ordre exact spécifié dans le tableau. De plus, si un élément est rejeté, la chaîne entière doit être rejetée immédiatement, empêchant ainsi toute tentative ultérieure de résolution des éléments suivants.

Itération manuelle

Voici un exemple illustrant une itération manuelle pour l'exécution séquentielle d'une promesse :

function processArray(array, fn) {
  var index = 0;

  function next() {
    if (index < array.length) {
      fn(array[index++]).then(next);
    }
  }
  return next();
}

Cette fonction prend un tableau et une fonction de retour de promesse fn comme arguments. Il parcourt le tableau, appelant fn sur chaque élément et transmettant le résultat à l'itération suivante.

Utilisation de .reduce() avec Promise

function processArray(array, fn) {
  return array.reduce((p, item) => {
    return p.then(() => {
      return fn(item).then((data) => {
        results.push(data);
        return results;
      });
    });
  }, Promise.resolve());
}

Cette approche utilise la méthode réduire() pour accumuler un éventail de résultats. Chaque élément du tableau est traité séquentiellement, la promesse renvoyée par fn étant utilisée pour avancer l'itération.

Utilisation de la bibliothèque de promesses Bluebird

La bibliothèque de promesses Bluebird fournit des méthodes pratiques pour gérer les opérations asynchrones, y compris l'itération séquentielle.

Promise.mapSeries(arr, (item) => {
  // process each individual item here, return a promise
  return processItem(item);
}).then((results) => {
  // process final results here
}).catch((err) => {
  // process error here
});

La méthode Promise.mapSeries() prend un tableau et une fonction produisant une promesse et renvoie un promesse qui se résout en un tableau de résultats résolus.

Utilisation de ES7 async/await

Avec la syntaxe ES7 async/await, les opérations asynchrones séquentielles peuvent être écrites de manière plus concise et lisible :

async function processArray(array, fn) {
  let results = [];
  for (let i = 0; i < array.length; i++) {
    let r = await fn(array[i]);
    results.push(r);
  }
  return results; // will be resolved value of promise
}

Dans cet exemple, la fonction processArray parcourt le tableau, en utilisant wait pour mettre la boucle en pause jusqu'à ce que chaque promesse soit renvoyée par fn est résolu.

Choisir la bonne approche

La meilleure approche pour synchroniser une séquence de promesses dépend de facteurs tels que le nombre d'éléments dans le tableau, la complexité de la fonction de traitement fn et le comportement de gestion des erreurs souhaité. Pour des tableaux plus petits et des fonctions de traitement simples, une itération manuelle ou l'utilisation de Promise.mapSeries() de Bluebird peut suffire. Pour des scénarios plus complexes, l'utilisation de async/await ou d'une solution personnalisée comme celle fournie dans la réponse finale peut être plus appropriée.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!