retry 提供了一個通用的重試框架，支持同步和異步操作。您可以輕鬆配置重試次數、延遲和錯誤處理，這使得它在各種場景中都非常實用。

promise-retry 允許您在 Promise 物件中實現重試，並支持自定義重試次數和延遲。它提供了一個簡單的 API 來配置重試邏輯，特別適合需要在異步操作中處理錯誤的場景。

exponential-backoff 專注於指數增長的重試策略，特別適合處理網絡請求中的暫時性錯誤。它自動計算重試延遲，隨著重試次數的增加而增長，這有助於減少對服務器的壓力。

async-retry 允許您自定義重試邏輯，包括重試次數、延遲時間和錯誤過濾。您可以根據錯誤類型或其他條件決定是否重試，這使得它在處理不穩定的網絡請求時非常靈活。

backoff 提供了多種重試策略，包括線性、指數和自定義增長。您可以輕鬆配置重試延遲和增長率，這使得它適合需要精確控制重試行為的場景。

retry 提供了基本的延遲控制，您可以設置靜態延遲或自定義延遲函數。這使得它在各種場景中都能夠滿足基本的延遲需求。

promise-retry 允許您設置靜態或動態延遲，並支持在重試過程中調整延遲。這使得它在處理異步操作中的錯誤時非常靈活。

exponential-backoff 自動計算指數增長的延遲，隨著重試次數的增加而增長。這有助於減少對服務器的瞬時壓力，特別是在處理網絡請求時。

async-retry 允許您自定義延遲時間，包括靜態延遲和動態延遲。您可以根據重試次數或錯誤類型來調整延遲，這使得它在處理不穩定的環境時非常靈活。

backoff 提供了靈活的延遲控制，支持線性和指數增長。您可以輕鬆設置初始延遲、增長率和最大延遲，這使得它適合需要精確控制延遲行為的場景。

retry 提供基本的錯誤處理功能，您可以在重試過程中添加自定義錯誤處理。這使得它在各種場景中都能夠滿足基本的錯誤處理需求。

promise-retry 允許您在重試過程中處理錯誤，包括記錄錯誤和自定義錯誤處理邏輯。這使得它在處理異步操作中的錯誤時非常靈活。

exponential-backoff 主要專注於重試邏輯，對錯誤處理的支持較少。您可以在重試過程中添加自定義錯誤處理，但需要手動實現。

async-retry 允許您自定義錯誤處理邏輯，包括記錄錯誤、過濾錯誤和最終錯誤處理。您可以根據錯誤類型決定是否重試，這使得它在處理複雜錯誤時非常靈活。

backoff 提供基本的錯誤處理功能，但主要專注於重試邏輯。您可以在重試過程中添加自定義錯誤處理，但需要手動實現。

retry 提供直觀的 API，特別是在配置重試次數和延遲方面。它的文檔清晰，幫助開發者快速理解和使用。

promise-retry 提供簡單的 API 來實現 Promise 物件的重試。它的文檔詳細，特別是在異步操作中的應用示例。

exponential-backoff 提供簡單的 API 來設置指數增長的重試策略。它的文檔清晰，特別適合需要快速實現指數重試的場景。

async-retry 提供簡單易用的 API，特別是在處理異步操作時。它的文檔清晰，並提供了多個示例，幫助開發者快速上手。

backoff 的 API 設計直觀，特別是在配置延遲和增長率方面。它的文檔詳細，並提供了多個示例，幫助開發者理解如何使用。

使用 retry 實現重試

const retry = require('retry');

function unreliableOperation() {
  // 模擬一個不可靠的操作
  const success = Math.random() > 0.6; // 40% 的成功率
  if (success) {
    return '成功';
  } else {
    throw new Error('操作失敗');
  }
}

const operation = retry.operation({
  retries: 5, // 最多重試 5 次
  factor: 2, // 每次重試延遲時間乘以 2
  minTimeout: 1000, // 最小延遲 1 秒
  maxTimeout: 8000, // 最大延遲 8 秒
});

operation.attempt((currentAttempt) => {
  console.log(`嘗試第 ${currentAttempt} 次`);
  try {
    const result = unreliableOperation();
    console.log(result);
  } catch (error) {
    console.error(error.message);
    if (operation.retry(error)) {
      console.log(`重試中...`);
    } else {
      console.error('所有重試均失敗:', operation.errors);
    }
  }
});

使用 promise-retry 實現重試

const promiseRetry = require('promise-retry');

function fetchData(retry) {
  // 模擬一個可能失敗的網絡請求
  const success = Math.random() > 0.5; // 50% 的成功率
  if (!success) {
    return retry(new Error('請求失敗')); // 觸發重試
  }
  return '數據';
}

promiseRetry((retry, number) => {
  console.log(`嘗試第 ${number} 次`);
  return fetchData(retry);
}, {
  retries: 3, // 最多重試 3 次
  minTimeout: 1000, // 最小延遲 1 秒
  maxTimeout: 5000, // 最大延遲 5 秒
}).then(result => {
  console.log('成功獲取數據:', result);
}).catch(error => {
  console.error('所有重試均失敗:', error);
});

使用 exponential-backoff 實現重試

const { ExponentialBackoff } = require('exponential-backoff');

async function fetchData() {
  // 模擬一個可能失敗的網絡請求
  throw new Error('網絡錯誤');
}

async function main() {
  const backoff = new ExponentialBackoff({
    minDelay: 1000, // 最小延遲 1 秒
    maxDelay: 10000, // 最大延遲 10 秒
    factor: 2, // 每次重試延遲時間乘以 2
    retries: 5, // 最多重試 5 次
  });

  try {
    await backoff.retry(fetchData);
  } catch (error) {
    console.error('所有重試均失敗:', error);
  }
}

main();

使用 async-retry 實現重試

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

async function fetchData() {
  // 模擬一個可能失敗的異步操作
  throw new Error('Network Error');
}

async function main() {
  try {
    const result = await retry(fetchData, {
      retries: 3, // 最多重試 3 次
      factor: 2, // 每次重試延遲時間乘以 2
      minTimeout: 1000, // 最小延遲 1 秒
      maxTimeout: 5000, // 最大延遲 5 秒
    });
    console.log('成功獲取數據:', result);
  } catch (error) {
    console.error('所有重試均失敗:', error);
  }
}

main();

使用 backoff 實現重試

const backoff = require('backoff');

function fetchData() {
  // 模擬一個可能失敗的操作
  return new Promise((resolve, reject) => {
    const success = Math.random() > 0.7; // 30% 的成功率
    if (success) {
      resolve('數據');
    } else {
      reject(new Error('操作失敗'));
    }
  });
}

const backoffStrategy = backoff.exponential({
  initialDelay: 1000, // 初始延遲 1 秒
  maxDelay: 10000, // 最大延遲 10 秒
});

backoffStrategy.failAfter(5); // 最多重試 5 次

backoffStrategy.on('ready', (number, delay) => {
  console.log(`準備重試第 ${number} 次，延遲 ${delay} 毫秒`);
});

backoffStrategy.on('fail', (error) => {
  console.error('所有重試均失敗:', error);
});

backoffStrategy.on('backoff', () => {
  fetchData().catch((error) => {
    console.error('操作失敗:', error);
    backoffStrategy.backoff(); // 觸發下一次重試
  });
});

backoffStrategy.backoff(); // 開始第一次嘗試