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

// 错误的fetch错误处理方式 (catch不会捕获HTTP错误状态码)
fetch(url)
  .then(response => {
    // 即使response.status是404或500，这里也会执行
    console.log('Fetch successful but status might be an error:', response.status);
    return response.json();
  })
  .catch(error => {
    // 只有网络错误才会进入这里
    console.error('Network error:', error);
  });

// 正确的fetch错误处理方式 (确保HTTP错误状态码也能被catch捕获)
fetch(url)
  .then(response => {
    if (!response.ok) {
      // 如果HTTP状态码表示错误，则抛出错误，使Promise进入拒绝状态
      throw new Error(`HTTP error! Status: ${response.status}`);
    }
    return response.json();
  })
  .catch(error => {
    // 现在可以捕获网络错误和HTTP错误状态码
    console.error('Operation failed:', error);
  });

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

// 最小重试等待时间
const kMinRetryTime = 100; // 100毫秒
// 每次重试额外增加的时间
const kPerRetryAdditionalTime = 500; // 每次重试额外增加500毫秒

/**
 * 计算基于重试次数的退避时间。
 * @param {number} retries 当前的重试次数（从1开始）。
 * @returns {number} 应该等待的毫秒数。
 */
function calcBackoff(retries: number): number {
    // 确保最小等待时间，并根据重试次数线性增加
    return Math.max(kMinRetryTime, (retries - 1) * kPerRetryAdditionalTime);
}

/**
 * 带有指数退避策略的异步重试函数。
 * @param {Function} fn 要执行的异步函数，它必须返回一个Promise。
 * @param {any} params 传递给fn的参数。
 * @param {number} [times=1e9 + 7] 最大重试次数。
 * @returns {Promise<any>} fn成功解析时的结果，或在所有重试失败后抛出的错误。
 */
export function retry(fn: Function, params: any, times: number = 1e9 + 7): Promise<any> {
    let retries = 0; // 记录当前的重试次数

    /**
     * 尝试执行fn并处理重试逻辑的内部函数。
     * @returns {Promise<any>}
     */
    function attempt(): Promise<any> {
        return fn(params).catch((err: Error) => {
            retries++; // 增加重试计数
            console.warn(`Attempt failed (retry ${retries}/${times}):`, err.message); // 使用warn提示失败

            if (retries <= times) {
                // 如果还有重试次数，则计算退避时间并延迟后再次尝试
                const backoffTime = calcBackoff(retries);
                console.log(`Retrying in ${backoffTime}ms...`);
                return delay(backoffTime).then(attempt);
            } else {
                // 如果所有重试都已用尽，则抛出原始错误
                console.error(`All retry attempts failed after ${times} tries.`);
                throw err;
            }
        });
    }

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

// 假设这是一个模拟的异步请求函数，有一定几率失败
async function mockFetchData(id: string): Promise<string> {
    const random = Math.random();
    if (random < 0.7) { // 70%的几率失败
        console.log(`Request for ${id} failed.`);
        // 模拟fetch的HTTP错误，需要手动抛出
        throw new Error(`Failed to fetch data for ${id} (simulated HTTP 500)`);
    }
    console.log(`Request for ${id} succeeded.`);
    return `Data for ${id}`;
}

// 调用重试函数
(async () => {
    try {
        const result = await retry(mockFetchData, "user-123", 5); // 最多重试5次
        console.log("Final successful result:", result);
    } catch (error) {
        console.error("Operation ultimately failed:", error.message);
    }
})();