Come restituire molte promesse in un ciclo e attendere che tutti facciano altre cose

Question

Ho un ciclo che chiama un metodo che fa roba asincrona. Questo ciclo può chiamare il metodo molte volte. Dopo questo ciclo ho un altro ciclo che deve essere eseguito solo quando tutte le cose asincrone sono fatte. Quindi questo illustra le mie esigenze:

for(i=0;i<5;i++){ 
    doSomeAsyncStuff();  
} 

for(i=0;i<5;i++){ 
    doSomeStuffOnlyWhenTheAsyncStuffIsFinish();  
} 

Non mi sono familiare così tanto con le promesse, quindi qualcuno potrebbe aiutarmi a raggiungere questo obiettivo?

Ecco come il mio doSomeAsyncStuff() si comportano:

doSomeAsyncStuff{ 
    var editor = generateCKEditor(); 
    editor.on('instanceReady',function(evt){ 
     doSomeStuff(); 
     // There should be the resolve() of the promises I think. 
    }) 
} 

Forse devo fare qualcosa di simile:

doSomeAsyncStuff{ 
    var editor = generateCKEditor(); 
    return new Promises(function(resolve,refuse){ 
     editor.on('instanceReady',function(evt){ 
      doSomeStuff(); 
      resolve(true); 
     }) 
    } 
} 

Ma io non sono sicuro della sintassi.

Answer 1

È possibile utilizzare Promise.all (spec, MDN) per questo: Si accetta una serie di singole promesse e restituisce un singolo promessa che si risolve quando tutti quelli che hai dato vengono risolti, o rifiutata quando uno di essi è respinto

Quindi, se si effettua doSomeAsyncStuff ritorno una promessa, quindi:

var promises = []; 

for(i=0;i<5;i+){ 
    promises.push(doSomeAsyncStuff()); 
} 

Promise.all(promises) 
    .then(() => { 
     for(i=0;i<5;i+){ 
      doSomeStuffOnlyWhenTheAsyncStuffIsFinish();  
     } 
    }) 
    .catch((e) => { 
     // handle errors here 
    }); 

Axel Rauschmayer ha un buon articolo su promesse here.

Ecco un esempio - live copy on Babel's REPL:

function doSomethingAsync(value) { 
 
     return new Promise((resolve) => { 
 
     setTimeout(() => { 
 
      console.log("Resolving " + value); 
 
      resolve(value); 
 
     }, Math.floor(Math.random() * 1000)); 
 
     }); 
 
    } 
 
    
 
    function test() { 
 
     let i; 
 
     let promises = []; 
 
     
 
     for (i = 0; i < 5; ++i) { 
 
     promises.push(doSomethingAsync(i)); 
 
     } 
 
     
 
     Promise.all(promises) 
 
      .then((results) => { 
 
      console.log("All done", results); 
 
      }) 
 
      .catch((e) => { 
 
       // Handle errors here 
 
      }); 
 
    } 
 
    
 
    test();

(non si è preoccupato con .catch su questo, ma si vuole .catch sui vostri reali, come illustrato in precedenza.)

Esempio di output (a causa del Math.random, cosa finisce per primo può variare):

 
Resolving 3 
Resolving 2 
Resolving 1 
Resolving 4 
Resolving 0 
All done [0,1,2,3,4]