Comment synchroniser une séquence de promesses en JavaScript ?

Synchronisation d'une séquence de promesses

Les promesses JavaScript fournissent un mécanisme puissant pour gérer les opérations asynchrones. Cependant, il existe des situations dans lesquelles nous devons synchroniser l'exécution des promesses dans un ordre précis. Ceci est particulièrement difficile lorsque nous voulons éviter une exécution précoce ou des interruptions dues à des promesses ultérieures.

Itération manuelle avec chaînage de promesses

Une approche simple pour synchroniser les promesses consiste à parcourir les manuellement, en enchaînant les promesses les unes après les autres :

function sequence(arr) {
  let index = 0;

  function next() {
    if (index < arr.length) {
      return arr[index++].then(next).catch(e => Promise.reject(e));
    }
  }

  return next();
}

Cette fonction parcourt le tableau des promesses, en résolvant chacune dans l'ordre et en gérant tout rejet.

Utilisation de la bibliothèque de promesses Bluebird

Bluebird est une bibliothèque de promesses populaire qui fournit des fonctionnalités supplémentaires pour le contrôle de la concurrence, notamment :

Promise.mapSeries(arr, function(item) {
  return processItem(item);
}).then(function(results) {
  // process final results here
}).catch(function(err) {
  // process array here
});

Utilisation d'ES7 Async/Await

ES7 introduit la syntaxe async/await, qui simplifie la programmation asynchrone et fournit un moyen naturel de séquencer les promesses :

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
}

Éviter l'exécution anticipée

Pour empêcher l'exécution anticipée des promesses, vous pouvez les créer dans la boucle au lieu de les déclarer à l'avance. Cela garantit que seule la promesse actuelle est exécutée avant la création de la suivante.

function sequenceDynamic(nextPromise) {
  let index = 0;

  function next() {
    const promise = nextPromise(index);
    if (promise) {
      return promise.then(() => next(++index)).catch(e => Promise.reject(e));
    }
  }

  return next();
}

Cette fonction mise à jour prend une fonction de rappel qui renvoie la prochaine promesse à exécuter. La fonction continue d'itérer tant que le rappel renvoie des promesses valides.

Conclusion

La synchronisation des promesses dans un ordre spécifique peut être obtenue via une itération manuelle, la bibliothèque Bluebird, async /await, ou en évitant une exécution anticipée. Il est important de sélectionner l'approche qui convient le mieux à votre application et à votre environnement de développement.

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!