Warten Sie, bis jedes Versprechen nach dem Fortsetzen der Schleife

Question

Ich unten habe zwei Funktionen. Eine der Antworten gibt ein Versprechen ab und ich möchte in jeder Schleife darauf warten, dass sie zuerst beendet wird und dann eine verschiebt. Wie Sie unten sehen werden, ist das Ergebnis nicht das gewünschte/synchrone Ergebnis. Soll ich async.forEachof nicht

function test(num, callback) 
{ 
    console.log("inside function: "+num) 
    return new Promise((resolve, reject) => { 
     my.promise(num).then(() => { 
      console.log("done: "+num) 
      resolve(callback); 
     }).catch(e => console.error(e)); 
    }).catch(console.error); 
} 

function start_function() 
{ 
    //stuff 
    async.forEachOf(arr, function (itm, i, callback){ 
     console.log(i) 
     test(i, callback).catch(e => console.error(e)); 
    }, function (err) { 
     console.log("ALL DONE") 
    }); 
} 

Ergebnis verwenden:

0 
inside function 0 
1 
inside function 1 
2 
inside function 2 
done: 0 
done: 2 //wrong should always be 1, finished before the previous promise. 
done: 1 //wrong 
ALL DONE 

Ich will nicht PromiseAll nicht verwenden, weil ich nicht will, sondern weil ich brauche jedes Versprechen für die vorherige Ergebnis zu warten, und dann starten der Nächste. Es ist daher sinnlos, sie alle zu sammeln und dann darauf zu warten, dass sie in welcher Reihenfolge und zu dem, was ich tun muss, getan werden.

Answer 1

Wenn ich nicht falsch bin, was genau Sie versuchen, zu tun, aber Sie sollten vermeiden Callback in Promise-Funktion übergeben und es zu lösen. Sie können dasselbe mit diesem Code erreichen und auch den Callback von der Testfunktion entfernen.

function start_function() 
{ 
    //stuff 
    arr.forEach(async function (itm, i, array){ 
     console.log(i) 
     try { 
      await test(i); 
     } 
     catch(err){ 
      console.log(err); 
     } 
    }); 
} 

Hier ist, wie Testfunktion wie

aussehen

function test(num) 
{ 
    console.log("inside function: "+num) 
    return new Promise((resolve, reject) => { 
     my.promise(num).then(() => { 
      console.log("done: "+num) 
      resolve(); 
     }).catch(e => { 
       console.error(e) 
       reject(e); 
     }); 
    }); 
} 

Answer 2

Was ist mit diesem Ansatz:

(function loopOnItems(i) {   

     dummyGoogleAPI.someAsyncMethod(data).then(function (_response) {     
      // do something with response   
     }) 
     .catch(function (error) { 
      console.error(error); 
     }); 

     if (--i){ 
      loopOnItems(i);  
     }// decrement i and call loopOnItems again if i > 0 
     else{ 
      _callback(errors); 
     }    
})(count); 

Sie haben einige count und wir rufen loopOnItems Methode bis count> 0