Question

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

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文本，返回一个url数组稍后将详细抓取的项目
getItem：处理HTML的文本 item的详细页面，返回将要写入的对象文件
writeItem：将目标写入文件，随目录提供和页码，以制作正确的目录，并编写和存储

我遇到了一个问题：

如何使用每个承诺队列重建它承诺将一个接一个，一个接一个地顺序运行同步并且只允许有限数量的promises同时运行？

如何正确有效地完成工作？我应该如何改变这些当前的代码？我还需要一些演示

我删除了fetchItem功能，因为它不必要（实际上，它使用fetchPage调用page = 0），现在我只使用fetchPage

Answer 1

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

对于您的问题，通常情况下，您不会将for循环与Promises结合使用，构建数据数组，以及返回Promise的映射函数，然后.map() + Promise.all()或{{1将数组转换为单个Promise，当所有内容都完成时解析。

Bluebird＆＃39; s .reduce()还允许您指定并发选项，这将限制可以同时运行的操作数。

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

同时运行异步操作

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

尝试将事物视为价值集合，以及您对这些值执行的操作，将您的操作抽象为函数，并在适当的时候调用它们，不要将获取与写入相同的位置混合。

Answer 2

首先，如果你想真正控制你的执行，那么你就不应该构造一个循环来调用一个promise。它将立即执行。相反，您应该构造一些要提供给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个并发作业。

node.js - 控制Promises队列

2 个答案:

同时运行异步操作

按顺序运行异步操作：