js实现retry

JavaScript 实现重试机制

在 JavaScript 中实现重试机制可以通过多种方式完成，以下是几种常见的方法：

使用递归实现重试

递归方法可以在操作失败时自动重试，直到达到最大重试次数或操作成功。

function retryOperation(operation, maxRetries, delay) {
  return new Promise((resolve, reject) => {
    function attempt(retryCount) {
      operation()
        .then(resolve)
        .catch(error => {
          if (retryCount >= maxRetries) {
            reject(error);
            return;
          }
          setTimeout(() => attempt(retryCount + 1), delay);
        });
    }
    attempt(0);
  });
}

使用 async/await 实现重试

async/await 语法使代码更易读，适合现代 JavaScript 开发。

async function retryAsyncOperation(operation, maxRetries, delay) {
  let lastError;
  for (let i = 0; i < maxRetries; i++) {
    try {
      const result = await operation();
      return result;
    } catch (error) {
      lastError = error;
      if (i < maxRetries - 1) {
        await new Promise(resolve => setTimeout(resolve, delay));
      }
    }
  }
  throw lastError;
}

使用第三方库实现重试

现有库如 async-retry 或 p-retry 提供了更完善的解决方案。

安装 p-retry：

npm install p-retry

使用示例：

const retry = require('p-retry');

async function fetchData() {
  // 模拟可能失败的操作
  const response = await fetch('https://api.example.com/data');
  if (!response.ok) {
    throw new Error('Request failed');
  }
  return response.json();
}

async function main() {
  try {
    const data = await retry(fetchData, { retries: 3 });
    console.log(data);
  } catch (error) {
    console.error('All retries failed:', error);
  }
}

main();

指数退避策略

对于网络请求，采用指数退避策略可以更有效地处理暂时性故障。

async function retryWithBackoff(operation, maxRetries, initialDelay) {
  let retryCount = 0;
  let currentDelay = initialDelay;

  while (true) {
    try {
      return await operation();
    } catch (error) {
      if (retryCount >= maxRetries) {
        throw error;
      }
      retryCount++;
      await new Promise(resolve => setTimeout(resolve, currentDelay));
      currentDelay *= 2; // 指数增加延迟时间
    }
  }
}

带条件重试

有时需要根据特定错误条件决定是否重试。

async function conditionalRetry(operation, shouldRetry, maxRetries, delay) {
  let lastError;
  for (let i = 0; i < maxRetries; i++) {
    try {
      const result = await operation();
      return result;
    } catch (error) {
      lastError = error;
      if (!shouldRetry(error) || i === maxRetries - 1) {
        throw lastError;
      }
      await new Promise(resolve => setTimeout(resolve, delay));
    }
  }
}

以上方法可以根据具体需求选择或组合使用，实现灵活的重试机制。