call.js async.each gọi lại, làm thế nào để tôi biết khi nào nó được thực hiện?

Question

Tôi đang cố gắng quấn đầu quanh Node.js và một số hoạt động không đồng bộ. Trong đoạn mã sau, tôi lấy một số nguồn cấp dữ liệu RSS và lưu trữ các bài báo tìm thấy nếu tôi chưa lưu chúng trước đó. Mã hoạt động và lưu trữ các bài viết mới. Tuy nhiên, tôi không chắc chắn làm thế nào để thay đổi điều này để tôi biết khi tất cả các bài viết được thực hiện được phân tích cú pháp. Ví dụ, gọi lại trên mỗi async.eachLimit được gọi mỗi lần giới hạn được đáp ứng (sau 10 bài viết hoặc 5 nguồn cấp dữ liệu). Vậy làm thế nào để tôi biết khi nào họ đã làm xong?

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

Đối với một, bạn đang gọi trước cách gọi lại quá sớm.

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

    callback(); 
} 

Bạn không nên gọi số callback trước khi hoàn tất. Nếu không, phương thức "hoàn thành" của bạn sẽ được gọi nhưng mã async của bạn sẽ vẫn đang chạy.

Vì vậy, thay vì thực hiện:

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

Chỉ cần làm

.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); 
     } 
    }); 
});