node.js - 控制Promises队列

Question

我正在编写一个爬虫,它将使用node.js从电子商务网站获取数据.我的每次获取输入都包含:

• url:该链接的URL
• directory:稍后应将输出文件写入的目录名称
• page:要查询的参数

每个页面都会获取一些项目,稍后将详细提取每个项目

这是我的fetchPage承诺(agent是require('superagent'))将获取HTML文本:

function fetchPage(url,page){
    return new Promise(
        (resolve,reject)=>{
            if (page>0){
                agent
                .get(url)
                .send('page='+page)
                .end(function(err,res){
                    if (err){
                        reject(err);
                    } else{
                        resolve(res.text);
                    }
                });
            } else{
                agent
                .get(url)
                .end(function(err,res){
                    if (err){
                        reject(err);
                    } else{
                        resolve(res.text);
                    }
                });
            }

        });
}

全球电话:

var data=[];
for (var i=1;i<=links[0].numOfPages;i++){
    data.push({
        url:links[0].url,
        directory:links[0].directory,
        page:i
    });
}

const promises=data.reduce(
    (promise,data)=>promise.then(()=>{
        fetchPage(data.url,data.page).then(
            (result)=>{
                const urls=getUrls(result);
                Promise.all(urls.map((url,i)=>fetchPage(url,0).then(
                        (result)=>{
                            var item=getItem(result);
                            item.url=url;
                            writeItem(item,data.directory,data.page,i+1);
                        },
                        (error)=>console.log(error)
                )));
            });
    }),
    Promise.resolve());

promises.then((values)=>console.log('All done'));

您将看到3个函数作为实用程序(所有这些函数都正常工作):

• getUrls:处理页面的HTML文本,稍后返回要详细爬网的项目网址数组
• getItem:处理项目详细页面的HTML文本,返回将写入文件的对象
• writeItem:将对象写入文件,提供目录和页码以制作正确的目录并进行写入和存储

我遇到了一个问题:

• 如何使用promises队列重建它,其中每个promise将逐个和一个接一个地顺序和同步地运行,并且只允许有限数量的promises同时运行？

如何正确有效地做到这一点？我应该如何更改这些当前代码？我也需要一些演示

我删除了fetchItem,因为它的innecessity(实际上,它调用的函数fetchPage用page = 0),现在我只能利用fetchPage

Answer 1

首先，如果你想真正控制你的执行，那么你不应该构造一个循环来调用一个promise。它将立即执行。相反，您应该构造一些要提供给承诺的数据。抱歉，我不太了解您的程序流程。我可以看到你正在打电话fetchPage，在它完成后，调用fetchItem，它fetchPage再次调用。这也许就是为什么您会收到双重回调的原因。

对于您的第二个问题，这里有一个示例，说明如何串行处理每个链接，并并行处理最多 3 个并发作业的链接中的页面。

var Promise = require('bluebird');
var chance = new (require('chance'))();

var fetchPage = (url, page) => new Promise((resolve, reject) => {
    // Simulate Network Operation
    if (page === 0) {
        console.log('Start Downloading: ' + url);
        setTimeout(() => {
            resolve({
                url: url,
                content: 'Content of ' + url
            });
        }, chance.integer({ min: 10, max: 250 }));
    } else {
        console.log('Start Downloading: ' + url + '?page=' + page);
        setTimeout(() => {
            resolve({
                url: url + '?page=' + page,
                content: 'Content of ' + url + '?page=' + page
            });
        }, chance.integer({ min: 10, max: 250 }));
    }
});

var fetchItem = link => {
    // Get the data to be supplied to fetchPage promise
    var data = [];
    for (var i = 0; i <= link.numOfPages; i++) {
        data.push({
            url: link.url,
            page: i
        });
    }
    return data;
};

var writeItem = (item, directory) => {
    // Simulate Writing to Directory
    console.log('Writing ' + item + ' to ' + directory + ' folder');
};

// Make some dummy links
var links = [];
for (var i = 0; i < 10; i++) {
    var domain = chance.domain();
    links.push({
        url: chance.url({ domain: domain }),
        directory: domain,
        numOfPages: chance.integer({ min: 0, max: 5 })
    });
}

// Process each URL serially
Promise.each(links, link => Promise.map(fetchItem(link), data => fetchPage(data.url, data.page).then(result => {
    writeItem(result.content, link.directory);
    console.log('Done Fetching: ' + result.url);
}), {
    // Control the number of concurrent job
    concurrency: 3
})).then(() => {
    console.log('All Done!!');
});

更新：一个更简单的例子来演示Promise.each和Promise.map

var Promise = require('bluebird');
var chance = new (require('chance'))();

var tasks = [];

for (var i = 1; i <= chance.integer({ min: 10, max: 20 }); i++) {
    var jobs = [];
    for (var j = 1; j <= chance.integer({ min: 2, max: 10 }); j++) {
        jobs.push({
            job_name: 'Job ' + j
        });
    }

    tasks.push({
        task_name: 'Task ' + i,
        jobs: jobs
    });
}

Promise.each(tasks, task => Promise.map(task.jobs, job => new Promise((resolve, reject) => {
    setTimeout(() => resolve(task.task_name + ' ' + job.job_name), chance.integer({ min: 20, max: 150 }));
}).then(log => console.log(log)), {
    concurrency: 3
}).then(() => console.log())).then(() => {
    console.log('All Done!!');
});

在这个例子中，你可以清楚地看到每个任务都是按顺序运行的，一个任务中的每个作业都是并行运行的，一次最多有 3 个并发作业。

Answer 2

对于您的情况,我建议您安装Bluebird Promise库,因为它提供了一些您可以使用的实用程序.

对于你的问题,通常,你不要将for循环与Promises一起使用,你构造一个数据数组,一个映射函数返回一个Promise,然后将一个.map() + Promise.all()或者.reduce()数组转换成一个Promise,当一切都完成时解析.

Bluebird Promise.map()还允许您指定并发选项,这将限制可以同时运行的操作数.

以下是一些可以帮助您入门的示例:

同时运行异步操作

const Promise = require('bluebird');
const urls = ['https://url1.com', 'https://url2.com', ... ]; // lots of urls
// {concurrency: 4} means only 4 URLs are processed at any given time.
const allPromise = Promise.map(urls, fetchUrlAsync, {concurrency: 4});
allPromise.then(allValues => {
  // Deal with all results in order of original array
});

按顺序运行异步操作:

const Promise = require('bluebird');
const urls = ['https://url1.com', 'https://url2.com', ... ]; // lots of urls
// {concurrency: 4} means only 4 URLs are processed at any given time.
const allPromise = urls.reduce((promise, url) => 
  // Start with an empty promise, chain all calls on top of that
  promise.then(() => fetchUrlAsync(url)), Promise.resolve()); 
allPromise.then(allValues => {
  // Deal with all results in order of original array
});

尝试将事物视为值的集合,以及对这些值执行的操作,将操作抽象为函数,并在适当时调用它们,不要在同一位置混合读取和写入.