Node.js NodeJS异步队列太快（减慢异步队列方法）
我有一个HTTPGET请求，我想解析响应并将其保存到我的数据库中 如果我独立地调用crawl（i），我会得到很好的结果。但是我必须从1到2000调用crawl（）。 我得到了很好的结果，但有些反应似乎丢失了，有些反应是重复的。我不知道如何调用成千上万的异步函数。我正在使用队列函数，但到目前为止，我仍然缺少一些数据，并且仍然有一些重复数据。我做错了什么？谢谢你的帮助 我的节点功能：Node.js NodeJS异步队列太快（减慢异步队列方法）,node.js,loops,asynchronous,web-crawler,Node.js,Loops,Asynchronous,Web Crawler,我有一个HTTPGET请求，我想解析响应并将其保存到我的数据库中 如果我独立地调用crawl（i），我会得到很好的结果。但是我必须从1到2000调用crawl（）。 我得到了很好的结果，但有些反应似乎丢失了，有些反应是重复的。我不知道如何调用成千上万的异步函数。我正在使用队列函数，但到目前为止，我仍然缺少一些数据，并且仍然有一些重复数据。我做错了什么？谢谢你的帮助 我的节点功能： function getOptions(i) { return { host: 'mag
function getOptions(i) {
return {
host: 'magicseaweed.com',
path: '/syndicate/rss/index.php?id='+i+'&unit=uk',
method: 'GET'
}
};
function crawl(i){
var req = http.request(getOptions(i), function(res) {
res.on('data', function (body) {
parseLocation(body);
});
});
req.end();
}
function parseLocation(body){
parser.parseString(body, function(err, result) {
if(result && typeof result.rss != 'undefined') {
var locationTitle = result.rss.channel[0].title;
var locationString = result.rss.channel[0].item[0].link[0];
var location = new Location({
id: locationString.split('/')[2],
name: locationTitle
});
location.save();
}
});
}
N = 2 //# of simultaneous tasks
var q = async.queue(function (task, callback) {
crawl(task.url);
callback();
}, N);
q.drain = function() {
console.log('Crawling done.');
}
for(var i = 0; i < 100; i++){
q.push({url: 'http://magicseaweed.com/syndicate/rss/index.php?id='+i+'&unit=uk'});
}
有没有办法降低异步队列方法的速度？您应该看看这个伟大的模块，它简化了类似这样的异步任务。您可以使用队列，简单示例如下：
N = # of simultaneous tasks
var q = async.queue(function (task, callback) {
somehttprequestfunction(task.url, function(){
callback();
}
}, N);
q.drain = function() {
console.log('all items have been processed');
}
for(var i = 0; i < 2000; i++){
q.push({url:"http://somewebsite.com/"+i+"/feed/"});
}
N=#同时执行的任务
var q=async.queue（函数（任务、回调）{
somehttprequestfunction（task.url，function（））{
回调（）；
}
}，N）；
q、 drain=函数（）{
console.log（'所有项目都已处理'）；
}
对于（变量i=0；i<2000；i++）{
q、 推送（{url:http://somewebsite.com/“+i+”/feed/”}）；
}
var q = async.queue(function (task, callback) {
crawl(task.url);
callback();
}, N);
// first, modify your 'crawl' function to take a callback argument, and call this callback after the job is done.
// then
var q = async.queue(function (task, next/* name this argument as 'next' is more meaningful */) {
crawl(task.url, function () {
// after this one is done, start next one.
next();
});
// or, more simple way, crawl(task.url, next);
}, N);
如果您想要.Vanilla JS而不需要花哨的库，还有另一个选择
var incrementer = 0;
var resultsArray = [];
var myInterval = setInterval(function() {
incrementer++
if(incrementer == 100){
clearInterval(myInterval)
//when done parse results array
}
//make request here
//push request result to array here
}, 500);
每半秒调用一次函数。在x个请求后强制同步和退出的简单方法。我知道我回答这个问题有点晚，但是我编写了一个解决方案，在测试api端点时，使用节点4或节点5来降低请求数：
var fs = require('fs');
var supertest = require('supertest');
var request = supertest("http://sometesturl.com/api/test/v1/")
var Helper = require('./check.helper');
var basicAuth = Helper.basicAuth;
var options = Helper.options;
fs.readFile('test.txt', function(err, data){
var parsedItems = JSON.parse(data);
var urlparts = []
// create a queue
for (let year of range(1975, 2016)) {
for (var make in parsedItems[year]){
console.log(year, make, '/models/' + year + '/' + make)
urlparts.push({urlpart:'/models/' + year + '/' + make, year: year, make: make})
}
}
// start dequeue
waitDequeue();
// This function calls itself after the makeRequest promise completes
function waitDequeue(){
var item = urlparts.pop()
if (item){
makeRequest(item)
.then(function(){
// wait this time before next dequeue
setTimeout(function() {
waitDequeue();
}, 3000);
})
} else {
write(parsedItems)
}
}
// make a request, mutate parsedItems then resolve
function makeRequest(item){
return new Promise((resolve, reject)=>{
request
.get(item.urlpart)
.set(options.auth[0], options.auth[1])
.set(options.type[0], options.type[1])
.end(function(err, res) {
if (err) return done1(err);
console.log(res.body)
res.body.forEach(function(model){
parsedItems[item.year][item.make][model] = {}
});
resolve()
})
})
}
// write the results back to the file
function write(parsedItems){
fs.writeFile('test.txt', JSON.stringify(parsedItems, null, 4), function(err){
console.log(err)
})
}
})
有点晚了，但我发现这是有效的！ 使用async，您可以在任务处理程序内部使用以下命令来减慢队列速度，例如：
var q = async.priorityQueue(function(task, callback) {
// your code process here for each task
//when ready to complete the task delay it by calling
async.whilst( //wait 6 seconds
function() {
return count < 10;
},
function(callback) {
count++;
setTimeout(function() {
callback(null, count);
}, 1000);
},
function (err, n) {
// n seconds have passed
callback(); //callback to q handler
}
); //whilst
} , 5);
var q=async.priorityQueue（函数（任务，回调）{
//您在这里为每个任务编写代码流程
//准备完成任务时，通过调用
async.while（//等待6秒
函数（）{
返回计数<10；
},
函数（回调）{
计数++；
setTimeout（函数（）{
回调（null，count）；
}, 1000);
},
函数（err，n）{
//n秒过去了
callback（）；//对q处理程序的回调
}
)；//同时
} , 5);
回调（）