javascript - 定时 promise 解决在之前用时间解决一次后立即返回

Question

我在这里的措辞上有点困难，但要点是我使用返回一个对象的 Promise.race (如下所示)。大多数时候，至少有一些 promise 会崩溃，但这是故意的。这仅意味着未找到产品。为了避免 Promise 返回空白，我使用 try catch block 来启动一个新的 15 秒的定时 Promise。这可以防止 Promise 返回空白，让最快完成的函数将其对象返回到 Promise.race。在使用 Windows 10 在 NodeJS 10 中进行测试时，这似乎工作得很好，但是当我将其移植到运行 NodeJS 8 和 Ubuntu 18.04 的 Linux 服务器时，我遇到了一些奇怪的行为。 Promise.race 工作得很好，直到我在启动 NodeJS 应用程序后第一次测试该功能以来已经过去了 15 秒。当这 15 秒过去后，当我尝试与正常的 Promise 竞争时，它会立即返回定时的 Promise。

我首先要兑现这些 promise 。 (不确定这是否重要，但这是通过 HTTP 请求调用的)

let product = await Promise.race([
        get_info_meny_joker(bar_code, "meny.no"),
        get_info_meny_joker(bar_code, "joker.no"),
        get_info_openfoodfacts(bar_code)
    ])

其中一个看起来像这样

async function get_info_meny_joker(bar_code, link) {

    try {
        let url = 'https://' + link + '/Sok/?query=' + bar_code

        let browser = await puppeteer.launch({args: ['--no-sandbox']})
        let page = await browser.newPage()

        await page.goto(url, { waitUntil: 'networkidle2' })

        let get_link = await page.evaluate(() => document.querySelector('.ws-product__title').getAttribute('href') )
        let product_name = await page.evaluate(() => document.querySelector('.ws-product__title').innerText )
let product_amount = await page.evaluate(() => document.querySelector('.ws-product__subtitle').innerText )
        let regex = "[0-9]+([gl]+|ml| [gl] | ml |kg| kg)"
        let match = product_amount.match(regex)
        match = match[0]
        /*let regex_index = new RegExp("[A-Za-z]")
        let index_match = regex_index.exec(match).index
        match = match.splice(index_match, 0, " ")*/
        product_amount = match

        await page.goto('https://' + link + '/' + get_link, { waitUntil: 'networkidle2' })

        const [first_product, second_product] = await page.$$('.ws-collapsable-block__heading');

        await page.screenshot({ path: "x.png" })

        second_product.click()

        await page.screenshot({ path: "y.png" })

        let img_url = await page.evaluate(() => document.querySelector('.lazyloaded').attributes[1].value)

        // Get a list of all the nutrients found on the page
        let nutrients_raw = await page.evaluate(() => {
            let nutrients_raw = document.querySelector('.ws-nutritional-content').children
            let nutrients = {}
            let i = 0
            for (let item of nutrients_raw) {
                nutrients[i + ""] = item.innerText
                i++
            }
            return nutrients
        });

        // Pretify the nutrients_raw to a nutrients object
        let nutrients = {}
        for (let i = 0; i < Object.size(nutrients_raw); i++) {
            let s = nutrients_raw[i]
            let type = s.slice(0, s.indexOf(':'))
            let amount = s.slice(s.indexOf(':') + 2, s.length)
            nutrients[type] = amount
        }

        return new Product(bar_code, product_name, product_amount, img_url, nutrients, link)

    } catch (err) {
        return await promise
    }

}

定时 promise 看起来像这样

let promise = new Promise((resolve, reject) => {
    let product = new Product()
    product.name = "Could not be located"
    setTimeout(() => resolve(product), 15000)
});

再说一遍，我可以 Promise.race 并且它工作得很好，直到我第一次与它们比赛以来已经过去了 15 秒。

(对这个问题来说并不重要，但我理解 Promise.race 函数是从堆栈中完全删除丢失的 Promise。奇怪的是它记得 15 秒已经过去了。)

Answer 1

您需要在此创建一个新的promise:

let promise = new Promise((resolve, reject) => {
    let product = new Product()
    product.name = "Could not be located"
    setTimeout(() => resolve(product), 15000)
});

每次您想使用它时。否则，当您开始使用计时器时，计时器已经运行了一段时间，并且它将在远小于 15000ms 的时间内触发，因为它已经运行了一段时间。事实上，如果自您创建 Promise 以来的时间超过 15000 毫秒，那么它就已经被解决了，当您在 .race() 中使用它时，竞赛将立即结束并解决这个问题 promise 。

Not important to the question, but I understood the Promise.race function as completely deleting the losing promises from the stack. Odd that it remembers 15 seconds has passed.

这是不正确的。 Promise.race() 不会删除任何内容。任何输掉比赛的 promise 都会继续下去。只是 Promise.race() 返回的 Promise 将在竞赛中的第一个 Promise 完成后立即解析。其他人继续顺利，并将按照自己的时间表完成。

<小时/>

您可能想要做的是将其放入一个函数中，并在您想要 15000ms promise 的任何时候调用该函数:

function timeoutPromise(t) {
    return new Promise(resolve => {
        let product = new Product();
        product.name = "Could not be located";
        setTimeout(() => resolve(product), t);
    });
}

然后，只要您想使用新的超时 promise ，您只需调用此函数即可获取新的 promise ，而不是您正在使用的已保存的 promise 变量。