node.js async.each कॉलबैक, मुझे यह कैसे पता चलेगा कि यह कब किया जाता है?

Question

मैं अपने सिर को नोड.जेएस और कुछ एसिंक ऑपरेशंस के चारों ओर लपेटने की कोशिश कर रहा हूं। निम्नलिखित कोड में, मैं कुछ आरएसएस फ़ीड प्राप्त करता हूं और लेखों को संग्रहीत करता हूं यदि मैंने उन्हें पहले संग्रहित नहीं किया है। कोड नए लेख काम करता है और स्टोर करता है। हालांकि, मुझे यकीन नहीं है कि इसे कैसे बदला जाए ताकि मुझे पता चले कि सभी लेखों को पार्स किया जा रहा है। उदाहरण के लिए, प्रत्येक async.eachLimit पर कॉलबैक प्रत्येक बार सीमा पूरी होने पर कॉल किया जाता है (10 लेख या 5 फ़ीड्स के बाद)। तो मुझे कैसे पता चलेगा कि वे कब कर रहे हैं?

var FeedParser = require('feedparser'); 
var request = require('request'); 
var mysql = require('mysql'); 
var async = require('async'); 

var connection = mysql.createConnection({ 
     host : 'localhost', 
     user : 'someuser', 
     password : 'somepass', 
     database : 'somedb' 
}); 

connection.connect(); 

connection.query('SELECT * FROM rssfeed', function(err, rows, fields) { 
     if(err == null){ 
       async.eachLimit(rows, 5, parseFeed, function(err) { 
         if(! err) { 
           //horray 
         } else { 
           console.log(err); 
         } 
       }); 
     } 
}); 

function parseFeed(feed, callback) { 
     var articles = []; 
     request(feed.link) 
     .pipe(new FeedParser()) 
     .on('error', function(error) { 
       callback(error); 
     }) 
     .on('meta', function(meta) { 
     }) 
     .on('readable', function() { 
       var stream = this, item; 
       item = stream.read(); 
       if(item != null) { 
         item.rssfeed_id = feed.id; 
         articles.push(item); 
       } 
     }) 
     .on('finish', function() { 
       async.eachLimit(articles, 10, parseArticle, function(err) { 
         if(! err) { 
           console.log('article each callback'); 
         } else { 
           callback(error); 
         } 
       }); 
     }); 
     callback(); 
} 
function parseArticle(item, callback) { 
     if(item.hasOwnProperty('rssfeed_id') && item.hasOwnProperty('guid') && item.hasOwnProperty('link') && item.hasOwnProperty('title')){ 
       connection.query('SELECT * FROM rssarticle WHERE rssfeed_id = ? AND guid = ?', [item.rssfeed_id, item.guid], function(err, rows, fields) { 
         if(rows.length == 0){ 
           connection.query('INSERT INTO rssarticle SET ?', { 
             rssfeed_id: item.rssfeed_id, 
             link: item.link, 
             title: item.title, 
             description: item.description, 
             publish_date: item.pubDate, 
             guid: item.guid 
           }, function(err, result){ 
             if(err != null){ 
               console.log(err); 
             } 
           }); 
         } 
       }); 
     } 
     callback(); 
} 

Answer 1

एक के लिए, आप अपने कॉलबैक को बहुत जल्दी कॉल कर रहे हैं।

function parseFeed(feed, callback) { 
    request 
    .streamStuff() 
    .streamStuff() 
    .streamStuff(); 

    callback(); 
} 

आपको पूरा होने से पहले callback पर कॉल नहीं करना चाहिए। अन्यथा आपकी "समाप्त" विधि को कॉल किया जाएगा लेकिन आपका एसिंक कोड वास्तव में अभी भी चल रहा है।

तो बजाय कर रही है:

.on('finish', function() { 
    async.eachLimit(articles, 10, parseArticle, function(err) { 
     if(! err) { 
      console.log('article each callback'); 
     } else { 
      callback(error); 
     } 
    }); 
}); 
callback(); 

बस कर

.on('finish', function() { 
    async.eachLimit(articles, 10, parseArticle, function(err) { 
     if(! err) { 
      // assuming this is a stub and really ends up doing `callback();` 
      console.log('article each callback'); 
     } else { 
      callback(error); 
     } 
    }); 
});