Question

我在下面的代码中使用了Node / Puppeteer，传递了一个用于遍历和抓取的大量URL。虽然我发现我越来越接近答案，但很难异步进行。我目前陷入与以下错误相关的问题。

UnhandledPromiseRejectionWarning: Unhandled promise rejection (rejection id: 17): Error: Protocol error (Target.createTarget): Target closed.

在while循环的每次迭代中都会发生一次此错误。虽然我不确定我可能做错了什么。

有人可以帮我做以下事项：
1）诊断错误的来源。
2）可能找到一种更有效的方式来异步遍历大量的URL。

async function subProc(list, batchSize) {
let subList = null;
let i = 0;

while (list.length > 0) {
    let browser = await puppeteer.launch();
    subList = list.splice(0, batchSize);
    console.log("Master List Size :: " + list.length);
    console.log("SubList Size :: " + subList.length);

    for (let j = 0; j < subList.length; j++) {
        promiseArray.push(new Promise((resolve, reject) => {
            resolve(pageScrape(subList[j], browser));
        }));
    }
    Promise.all(promiseArray)
        .then(response => {
            procArray.concat(response);
        });
    promiseArray = new Array();
    try {
        await browser.close();
    } catch(ex){
        console.log(ex);
    }
};
}

async function pageScrape(url, browser) {
let page = await browser.newPage();
await page.goto(url, {
    timeout: 0
});
await page.waitFor(1000);
return await page.evaluate(() => {
    let appTitle = document.querySelector('').innerText;
    let companyName = document.querySelector('').innerText;
    let dateListed = document.evaluate("", document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue.innerText;
    let category = document.evaluate("']//a//strong", document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue.innerText;
    /*  */
    return {
        appTitle,
        companyName,
        dateListed,
        category
    }
}).then(response => {
    let urlData = {
        id: subList[j],
        appName: response.appTitle,
        companyName: response.companyName,
        dateListed: response.dateListed,
        category: response.category
    }
    return urlData;
});

};

Answer 1

我找到了解决我遇到的问题的方法。每台计算机的处理能力都有限，因此不必同时迭代1000个网址，而是必须将其分解成更小的部分。

通过使用PromiseAll，一次迭代和抓取10个url并将这些值存储在一个数组中，我能够限制迭代所有1000个url所需的处理。

 processBatch(subData, 10, procArray).then((processed)=>{
            for(let i = 0; i < procArray.length; i++){
                for(let j = 0; j < procArray[i].length; j++){
                   results.push(procArray[i][j]);
                }
            }

 function processBatch(masterList, batchSize, procArray){
    return Promise.all(masterList.splice(0, batchSize).map(async url => 
    {
    return singleScrape(url)
    })).then((results) => {
    if (masterList.length < batchSize) {
        console.log('done');
        procArray.push(results);
        return procArray;
    } else {
        console.log('MasterList Size :: ' + masterList.length);
        procArray.push(results);
        return processBatch(masterList, batchSize, procArray);
    }
   })
 }

Puppeteer / Node - Target.createTarget - 目标已关闭

1 个答案: