Comment exécuter les promesses de manière séquentielle, en passant les paramètres à partir d'un tableau?

var myArray = [1, 2, 3, 4, 5, 6]

function myPrommise(num){
  return new Promise(res => {
    window.setTimeout(()=>{
      res(  console.log("done: " + num)  )
    },2000)
  })
}


myPrommise(myArray[0])
  .then(x => myPrommise(myArray[1]))
  .then(x => myPrommise(myArray[2]))
  .then(x => myPrommise(myArray[3]))
  .then(x => myPrommise(myArray[4]))
  .then(x => myPrommise(myArray[5]))

Droit maintenant, si je exécuter l'instruction ci-dessus, il sera exécuté de manière séquentielle. Dans mon cas d'utilisation le tableau est rempli dynamiquement et j'ai besoin d'exécuter le myPromise() fonction de chaque membre myArray.

Comment puis-je faire un "pauseable boucle" qui passe en boucle pour chaque élément d'un tableau, d'exécuter myPromise et d'attendre la promesse d'être résolus avant de poursuivre à la prochaine itération?

Promesse.Tout ce que vous voulez
Sur son propre, ce n'est pas suffisant, car il ne permettra pas de résoudre de manière séquentielle.

OriginalL'auteur David Alsh | 2017-03-29

  1. 6

    Ne pas créer un tableau de promesses. Créer un tableau de fonctions retournant une promesse.

    const f = x => new Promise(resolve => setTimeout(() => resolve(console.log(x)), 2000))

(async () => {
    for (let job of [1, 2, 3, 4, 5, 6].map(x => () => f(x)))
        await job()
})()

    Promesses commence à fonctionner immédiatement après la création. Par conséquent, l'exécution séquentielle est assurée par la construction de la prochaine promesse seulement après la fin de l'actuel.

    OriginalL'auteur jdh8

  2. 2

    Vous pouvez utiliser Array.réduire.

    //type: [number]
var myArray = [1, 2, 3, 4, 5, 6] //doesn't really matter

//type: number -> Promise<number>
function myPromise(num){
  return new Promise((resolve) => {
    window.setTimeout(()=>{
      resolve(console.log("done: " + num)  )
    },2000)
  })
}

//Array.reduce has type: [a] ~> ((b, a) -> b), b) -> b
//So it can have type:
//[number] ~> ((Promise<number>, number) -> Promise<number>), Promise<number>) -> Promise<number>
//Therefore we need to give reduce a function that takes a Promise 
//resolving to a number and a number which makes a new promise.
//This is the function we want:

function sequencePromises(promise, number) {
  return new Promise((resolve) => {
    resolve(promise.then(_ => myPromise(number)));
  });
} 

myArray.reduce(sequencePromises, Promise.resolve());

    Bien sûr, cette approche simpliste ne fonctionnera pas si vous avez une promesse qui peut d'erreur, ou si vous avez besoin d'résultats précédents, de sorte que vous voudrez peut-être faire sequencePromises plus générique:

    function genericSequencePromises(promiseFunction) {
  return (promise, parameter) => {
    return new Promise((resolve, reject) => 
                         return promiseFunction(resolve, 
                                                reject, 
                                                promise, 
                                                parameter));
  }
}

    Puis vous pouvez faire ce que vous voulez aussi longtemps que vous le retour d'une Promesse.

    Enfin, vous pouvez bénéficier de cette aide:

    function promiseSeries(array, reducer) {
  return array.reduce(reducer, Promise.resolve());
}

    Réunissant tout:

    let sequencePromises = genericSequencePromises((resolve, reject, promise, num) => {
  resolve(promise.then(_ => console.log(`done: ${num}`)));
}

promiseSeries(myArray, sequencePromises);

    De cette façon, vous pouvez non seulement gérer le cas dans votre question, mais beaucoup de cas plus complexes.

    OriginalL'auteur Pedro Castilho