come interrompere async.js ogni ciclo?

Question

Ciao sto usando il modulo async di node.js per implementare un ciclo for in modo asincrono.

La mia domanda è: come interrompere l'esecuzione del ciclo e uscire dal ciclo? Ho provato a dare return, return false ma senza fortuna.

Ecco il codice di esempio:

async.until( 

    function() { return goal; }, 

    function(callback) { 

     async.each(_rules, 

      function(rule,callback) { 

       var outcome = true; 
       .... some code .... 
       if(changes){ 
         console.log("hi"); 
         return false;// HERE I NEED TO BREAK 
       } 
       else 
       callback(); 

      }, 

      function(err){ } 
     ); 

     if (!changes || session.process)     
      goal = true; 

     callback(); 
    }, 

    function(err){ callback(session); }  
); 

Answer 1

async.until chiama ripetutamente la funzione fino a quando il test restituisce vero. Quindi il test deve restituire true in modo da uscire dal ciclo. Questo è l'opposto di async.whilst che viene eseguito ripetutamente mentre il test viene valutato come vero.

async.each chiama le funzioni in parallelo, quindi ciò che ritorna non ha importanza. Non è un ciclo che puoi interrompere, ma un iteratore che si muove sopra l'array. La tua condizione di smettere di usare async.each dovrebbe essere in prova per async.until e dovresti scorrere le regole da solo.

Answer 2

In realtà non esiste un "loop" in quanto tale da cui uscire. Tutti i tuoi articoli nella tua collezione sono usati in parallelo

L'unico modo per "interrompere" il "ciclo" è chiamare il callback con un argomento di errore. Dato che non c'è nulla che ti impedisca di mettere altre cose lì dentro, potresti modificarlo un po '.

Dalla documentazione:

noti che poiché questa funzione si applica l'iteratore a ciascun elemento parallelo v'è alcuna garanzia che le funzioni iteratore complete in ordine.

Anche se si restituisce un errore, si avranno ancora diverse richieste in sospeso potenzialmente così si vuole veramente limitare la quantità di oggetti che si usano in una volta. Per limitare la quantità di richieste in sospeso, è possibile utilizzare eachSeries o EachLimit.

Ad esempio:

async.each(_rules, 
     function(rule,callback) { 
      if(changes){      
        return callback({ data: 'hi'}); // stop 
      } 
      ... 
      if(realerror){ 
       return callback({ error: realerror}); // stop with an error 
      } 
      callback(); // continue 
     }, 

     function(result){ 
      if(!result){ 
      return othercallback('no results'); 
      } 
      // check if we have a real error: 
      if(result.error){ 
      return othercallback(result.error); 
      } 
      return othercallback(null, result.data); 
     } 
    ); 

PS: se non stai facendo asincrona, utilizzare underscore