Comment résoudre les promesses JavaScript de manière séquentielle ?

​​​​​​​Résoudre les promesses de manière séquentielle

Les promesses sont un moyen courant de gérer les opérations asynchrones en JavaScript. Cependant, il peut être difficile de contrôler l'ordre dans lequel les promesses sont résolues.

Le problème :

Considérez le code suivant qui lit une série de fichiers en série :

var readFile = function(file) {
  ... // Returns a promise.
};

var readFiles = function(files) {
  return new Promise((resolve, reject) => {
    var readSequential = function(index) {
      if (index >= files.length) {
        resolve();
      } else {
        readFile(files[index]).then(function() {
          readSequential(index + 1);
        }).catch(reject);
      }
    };

    readSequential(0); // Start with the first file!
  });
};

Ce code utilise la récursion pour lire les fichiers les uns après les autres, mais il peut être difficile à travailler with.

Éviter la récursion avec Async/Await :

Dans JavaScript moderne, l'utilisation des fonctions async et wait est une solution plus élégante :

async function readFiles(files) {
  for(const file of files) {
    await readFile(file);
  }
};

Vous pouvez également utiliser des itérateurs :

Les générateurs asynchrones offrent une alternative approche de lecture séquentielle des fichiers :

async function* readFiles(files) {
  for(const file of files) {
    yield await readFile(file);
  }
};

Envisagez une boucle simple :

Si vous préférez une approche plus simple, une boucle for de base peut suffire :

var readFiles = function(files) {
  var p = Promise.resolve(); // Q() in q

  files.forEach(file =>
      p = p.then(() => readFile(file)); 
  );
  return p;
};

Ou, utilisez la réduction de promesse :

Une solution plus compacte en utilisant réduire :

var readFiles = function(files) {
  return files.reduce((p, file) => {
     return p.then(() => readFile(file));
  }, Promise.resolve()); // initial
};

Méthodes utilitaires de bibliothèque

Certaines bibliothèques de promesses (par exemple, Bluebird) fournissent des méthodes utilitaires adaptées à cet effet :

var Promise = require("bluebird");
var fs = Promise.promisifyAll(require("fs"));

var readAll = Promise.resolve(files).map(fs.readFileAsync,{concurrency: 1 });
// if the order matters, you can use Promise.each instead and omit concurrency param

readAll.then(function(allFileContents){
    // do stuff to read files.
});

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!