Delay ogni iterazione del ciclo in js nodo, asincrono

Question

Ho il codice qui sotto:

var request = require('request'); 
var cheerio = require ("cheerio"); 
var async= require("async"); 

var MyLink="www.mylink.com"; 

    async.series([ 

     function(callback){ 
      request(Mylink, function (error, response, body) { 
       if (error) return callback(error); 
       var $ = cheerio.load(body); 
       //Some calculations where I get NewUrl variable... 
       TheUrl=NewUrl; 
       callback(); 
      }); 
     }, 
     function(callback){ 
      for (var i = 0; i <=TheUrl.length-1; i++) { 
       var url = 'www.myurl.com='+TheUrl[i]; 
       request(url, function(error, resp, body) { 
        if (error) return callback(error); 
        var $ = cheerio.load(body); 
        //Some calculations again... 
        callback(); 
       }); 
      }; 
     } 
     ], function(error){ 
     if (error) return next(error); 
    }); 

Qualcuno ha un suggerimento su come posso ritardare ogni iterazione del ciclo nel for loop? Ad esempio, il codice attende 10 secondi dopo il completamento di ogni iterazione. Ho provato setTimeout ma non sono riuscito a farlo funzionare.

Answer 1

È possibile impostare un timeout per l'esecuzione del codice a intervalli crescenti come questo:

var interval = 10 * 1000; // 10 seconds; 

for (var i = 0; i <=TheUrl.length-1; i++) { 
    setTimeout(function (i) { 
     var url = 'www.myurl.com='+TheUrl[i]; 
     request(url, function(error, resp, body) { 
      if (error) return callback(error); 
      var $ = cheerio.load(body); 
      //Some calculations again... 
      callback(); 
     }); 
    }, interval * i, i); 
} 

Quindi la prima si corre subito (intervallo * 0 è 0), secondo corre dopo dieci secondi, ecc.

È necessario inviare i come parametro finale nello setTimeout() in modo che il suo valore sia associato all'argomento della funzione. Altrimenti il ​​tentativo di accedere al valore dell'array sarà fuori limite e otterrai undefined.

Answer 2

Poiché si sta già utilizzando async, async.wilst farebbe bene come sostituto per for.

whilst è una funzione asimmetrica while -like. Ogni iterazione viene eseguita solo dopo che l'iterazione precedente ha chiamato il suo callback di completamento. In questo caso, possiamo semplicemente posticipare l'esecuzione della callback di completamento di 10 secondi con setTimeout.

var i = 0; 
async.whilst(
    // test to perform next iteration 
    function() { return i <= TheUrl.length-1; }, 

    // iterated function 
    // call `innerCallback` when the iteration is done 
    function(innerCallback) { 
     var url = 'www.myurl.com='+TheUrl[i]; 
     request(url, function(error, resp, body) { 
      if (error) return innerCallback(error); 
      var $ = cheerio.load(body); 
      //Some calculations again... 

      // wait 10 secs to run the next iteration 
      setTimeout(function() { i++; innerCallback(); }, 10000); 
     }); 
    }, 

    // when all iterations are done, call `callback` 
    callback 
); 

Answer 3

Un'altra alternativa sarebbe utilizzare async.eachSeries. Per esempio:

async.eachSeries(TheUrl, function (eachUrl, done) { 
    setTimeout(function() { 
     var url = 'www.myurl.com='+eachUrl; 
     request(url, function(error, resp, body) { 
      if (error) return callback(error); 
      var $ = cheerio.load(body); 
      //Some calculations again... 
      done(); 
     }); 
    }, 10000); 
}, function (err) { 
    if (!err) callback(); 
});