构建健壮的异步重试机制：深入理解Promise.catch与退避策略

/**
 * 创建一个延迟指定毫秒数的Promise
 * @param t 延迟时间（毫秒）
 * @returns 一个在指定时间后解决的Promise
 */
function delay(t: number): Promise<void> {
    return new Promise(resolve => setTimeout(resolve, t));
}

// 配置常量，用于计算退避时间
const kMinRetryTime = 100; // 最小重试间隔（毫秒）
const kPerRetryAdditionalTime = 500; // 每次重试额外增加的间隔（毫秒）

/**
 * 根据重试次数计算退避时间
 * @param retries 当前已重试的次数
 * @returns 计算出的退避时间（毫秒）
 */
function calcBackoff(retries: number): number {
    // 确保至少有最小重试时间，并根据重试次数线性递增
    return Math.max(kMinRetryTime, (retries - 1) * kPerRetryAdditionalTime);
}

/**
 * 带有退避策略的异步重试函数
 *
 * @template T 异步函数返回的Promise的解决类型
 * @param fn 需要重试的异步函数，必须返回一个Promise。它将接收params作为其参数。
 * @param params 传递给fn的参数
 * @param times 最大重试次数（包括第一次尝试，如果失败则重试次数为times-1）。默认为一个很大的值。
 * @returns 原始fn的Promise结果。如果达到最大重试次数仍失败，则抛出原始错误。
 */
export function retry<T>(fn: (...args: any[]) => Promise<T>, params: any, times = 1e9 + 7): Promise<T> {
    let retries = 0; // 当前已重试的次数

    // 内部递归函数，执行一次尝试并处理重试逻辑
    function attempt(): Promise<T> {
        return fn(params).catch((err: Error) => {
            retries++; // 增加重试计数
            console.error(`重试失败 (第 ${retries} 次):`, err.message || err); // 使用console.error更合适

            if (retries <= times) {
                // 还有重试次数，计算退避时间并延迟后再次尝试
                const backoffTime = calcBackoff(retries);
                console.warn(`等待 ${backoffTime}ms 后进行第 ${retries + 1} 次重试...`);
                // 返回一个Promise链：先延迟，然后再次调用attempt
                return delay(backoffTime).then(attempt);
            } else {
                // 重试次数耗尽，抛出原始错误，终止重试链
                console.error(`达到最大重试次数 (${times})，重试最终失败。`);
                throw err;
            }
        });
    }

    // 启动第一次尝试
    return attempt();
}

// 模拟一个异步请求函数，有一定几率失败
let requestAttemptCount = 0;
async function mockFetch(url: string): Promise<string> {
    requestAttemptCount++;
    console.log(`[${new Date().toLocaleTimeString()}] 尝试请求 ${url} (实际请求次数: ${requestAttemptCount})`);
    if (requestAttemptCount < 3) { // 模拟前两次失败
        throw new Error(`模拟网络错误或服务器错误 (第${requestAttemptCount}次失败)`);
    }
    return `数据来自 ${url} (成功于第 ${requestAttemptCount} 次尝试)`;
}

async function fetchDataWithRetry() {
    try {
        requestAttemptCount = 0; // 重置计数器
        console.log("--- 开始带退避策略的重试 ---");
        const result = await retry(mockFetch, "https://api.example.com/data", 5); // 最多重试5次
        console.log("--- 重试成功 ---");
        console.log("最终结果:", result);
    } catch (error: any) {
        console.error("--- 重试最终失败 ---");
        console.error("错误信息:", error.message);
    }
}

fetchDataWithRetry();

--- 开始带退避策略的重试 ---
[10:30:00 AM] 尝试请求 https://api.example.com/data (实际请求次数: 1)
重试失败 (第 1 次): 模拟网络错误或服务器错误 (第1次失败)
等待 100ms 后进行第 2 次重试...
[10:30:00 AM] 尝试请求 https://api.example.com/data (实际请求次数: 2)
重试失败 (第 2 次): 模拟网络错误或服务器错误 (第2次失败)
等待 500ms 后进行第 3 次重试...
[10:30:01 AM] 尝试请求 https://api.example.com/data (实际请求次数: 3)
--- 重试成功 ---
最终结果: 数据来自 https://api.example.com/data (成功于第 3 次尝试)