node.js - 一起使用 Promise 和 async

Question

我对 Node.js 有点陌生，我正在尝试理解使用错误处理并等待正确获取响应的想法。

所以我从网页请求一些数据，然后如果我得到了数据，它就完成了，但如果没有，那么它应该再次重试并获得增益，直到达到最大数量。

这是我的代码:

const getData = (url) => {
    return new Promise((resolve, reject) => {
        const options = {
            method: 'GET',
            url: 'my url',
            headers: {
                Accept: 'application/json'
            }
        }
        function callBack(error, response) {
            if (!error) {
                let data = response.data;
                return resolve({ success: true, data: data, statusCode: response.statusCode })
            } else {
                return reject({ success: false, error: error })
            }
        }
        request(options, callBack)
    })
}

let count = 1
const retry = async (max, next) => {
    let result = await getData(url)
    if (result.code !== 200) {
        while (count < max) {
            console.log('failed, retrying... ' + count);
            count = count + 1
            retry(max, next);
        }
        return next('max retries reached', null)
    }
    console.log('success');
    next(null, result.data)
}

因此，在这部分之后，我尝试运行重试，直到获得 5 次数据，例如:

retry(5, 3000, function (err, data) {
   if (!err) {
      return data
   }
   return err                                
})

但是像这样运行重试函数意味着我不会等到获取数据。在调用重试函数时，如何使用 try/catch 或 .then 的想法，以便它等待我的数据到来？

Answer 1

在 retry() 中，您需要迭代(使用 while 循环)或递归(使用 retry() 调用自身)，但不能同时执行两者。

如果您选择递归，请务必返回retry()。

传递 next 函数不是必需的，因为 retry() 将返回一个 promise 。因此，在重试的调用方中，您可以链接 retry().then(...) 或 async/await 等效项。

按照这些思路应该可以做到:

const retry = async(max, count) => {
    count = count || 0;
    let result;
    if(count >= max) { // top test; ensures that getData() isn't run even if say `retry(5, 10)` was accidentally (or deliberately) called.
        throw new Error('max reached'); // will not be caught below and will terminate the trying.
    }
    try {
        result = await getData(url);
        if(result.code !== 200) {
            throw new Error(`getData() was unsuccessful (${result.code})`); // will be caught and acted on below
        }
        return result.data; // will bubble upwards through the call stack to retry's original caller
    }
    catch(error) {
        // all errors ending up here qualify for a retry
        console.log(error.message, `retrying... (${count})`);
        return retry(max, count + 1); // recurse
    }
}

// call as follows
retry(5).then(function(data) {
    // work with `data`
}).catch(function(error) {
    console.log(error);
    // take remedial action, rethrow `error`, or do nothing
});

实际上，您可能会选择在重试之间引入延迟，以便为数据源提供更多时间来更改状态。