如何重试 Promise 决议 N 次，并在尝试之间有延迟？

我想要一些 JavaScript 代码将 3 个东西作为参数：

• 返回 Promise 的函数。
• 最大尝试次数。
• 每次尝试之间的延迟。

我最终做的是使用for环形。我不想使用递归函数：这样，即使有 50 次尝试，调用堆栈也不会长 50 行。

这里是打字稿代码版本：

/**
 * @async
 * @function tryNTimes<T> Tries to resolve a {@link Promise<T>} N times, with a delay between each attempt.
 * @param {Object} options Options for the attempts.
 * @param {() => Promise<T>} options.toTry The {@link Promise<T>} to try to resolve.
 * @param {number} [options.times=5] The maximum number of attempts (must be greater than 0).
 * @param {number} [options.interval=1] The interval of time between each attempt in seconds.
 * @returns {Promise<T>} The resolution of the {@link Promise<T>}.
 */
export async function tryNTimes<T>(
    {
        toTry,
        times = 5,
        interval = 1,
    }:
        {
            toTry: () => Promise<T>,
            times?: number,
            interval?: number,
        }
): Promise<T> {
    if (times < 1) throw new Error(`Bad argument: 'times' must be greater than 0, but ${times} was received.`);
    let attemptCount: number;
    for (attemptCount = 1; attemptCount <= times; attemptCount++) {
        let error: boolean = false;
        const result = await toTry().catch((reason) => {
            error = true;
            return reason;
        });

        if (error) {
            if (attemptCount < times) await delay(interval);
            else return Promise.reject(result);
        }
        else return result;
    }
}

The delay上面使用的函数是一个约定的超时：

/**
 * @function delay Delays the execution of an action.
 * @param {number} time The time to wait in seconds.
 * @returns {Promise<void>}
 */
export function delay(time: number): Promise<void> {
    return new Promise<void>((resolve) => setTimeout(resolve, time * 1000));
}

澄清一下：上面的代码works，我只是想知道这是否是一种“好的”方法，如果不是，我该如何改进它。

有什么建议吗？在此先感谢您的帮助。

我不想使用递归函数：这样，即使有 50 次尝试，调用堆栈也不会长 50 行。

这不是一个好的借口。调用堆栈不会因异步调用而溢出，并且当递归解决方案比迭代解决方案更直观时，您可能应该采用它。

我最终做的是使用for环形。这是一种“好”的做法吗？如果不是，我该如何改进？

The for循环很好。有点奇怪，它开始于1不过，基于 0 的循环更为惯用。

然而，不好的是你奇怪的错误处理。那个布尔值errorflag 不应在您的代码中占有一席之地。Using .catch() is fine https://stackoverflow.com/questions/44663864/correct-try-catch-syntax-using-async-await, but try/catch也会同样有效，并且应该是首选。

export async function tryNTimes<T>({ toTry, times = 5, interval = 1}) {
    if (times < 1) throw new Error(`Bad argument: 'times' must be greater than 0, but ${times} was received.`);
    let attemptCount = 0
    while (true) {
        try {
            const result = await toTry();
            return result;
        } catch(error) {
            if (++attemptCount >= times) throw error;
        }
        await delay(interval)
    }
}