retry vs promise-retry vs exponential-backoff vs async-retry vs backoff | "Wiederholungsstrategien in Node.js" npm-Pakete Vergleich

Paket	Downloads	Stars	Größe	Issues	Veröffentlichung	Lizenz

retry	42,330,914	1,247	-	19	vor 4 Jahren	MIT
promise-retry	16,078,728	317	-	11	vor 5 Jahren	MIT
exponential-backoff	12,458,966	370	55.2 kB	6	vor 2 Monaten	Apache-2.0
async-retry	9,697,574	1,871	-	30	vor 4 Jahren	MIT
backoff	712,113	337	-	11	vor 9 Jahren	MIT

Paket

Downloads

Stars

Größe

Issues

Veröffentlichung

Lizenz

retry

42,330,914

1,247

vor 4 Jahren

MIT

promise-retry

16,078,728

317

vor 5 Jahren

MIT

exponential-backoff

12,458,966

370

55.2 kB

vor 2 Monaten

Apache-2.0

async-retry

9,697,574

1,871

vor 4 Jahren

MIT

backoff

712,113

337

vor 9 Jahren

MIT

Wiederholungsstrategie

retry:
retry bietet eine vielseitige Wiederholungsstrategie, die sowohl für Callback- als auch für Promise-basierte Funktionen geeignet ist. Es unterstützt verschiedene Backoff-Strategien, einschließlich linearer und exponentieller Backoff, und ermöglicht eine umfassende Konfiguration der Wiederholungslogik.
promise-retry:
promise-retry bietet eine einfache Wiederholungsstrategie für Promise-basierte Funktionen, bei der die Funktion bei einem Fehler erneut aufgerufen wird. Die Anzahl der Wiederholungen und die Wartezeit können konfiguriert werden, wobei die Möglichkeit besteht, benutzerdefinierte Bedingungen für die Wiederholung festzulegen.
exponential-backoff:
exponential-backoff implementiert eine einfache exponentielle Backoff-Strategie, bei der die Wartezeit zwischen den Wiederholungen exponentiell zunimmt. Es ist eine spezialisierte Lösung für Anwendungen, die diese spezifische Strategie benötigen.
async-retry:
async-retry verwendet eine einfache Wiederholungsstrategie, die die Funktion bei einem Fehler erneut aufruft. Die Anzahl der Wiederholungen und die Wartezeit zwischen den Wiederholungen können konfiguriert werden, einschließlich der Unterstützung für exponentielles Backoff.
backoff:
backoff bietet eine flexible und anpassbare Wiederholungsstrategie, die es Entwicklern ermöglicht, verschiedene Backoff-Algorithmen zu verwenden, einschließlich linearer und exponentieller Backoff-Strategien. Es ermöglicht auch die Implementierung benutzerdefinierter Backoff-Logik.

Backoff-Implementierung

retry:
retry bietet eine flexible Implementierung von Backoff-Strategien, die sowohl lineares als auch exponentielles Backoff unterstützt. Die Bibliothek ermöglicht eine umfassende Konfiguration der Backoff-Logik, einschließlich der Möglichkeit, benutzerdefinierte Backoff-Algorithmen zu verwenden.
promise-retry:
promise-retry implementiert Backoff durch die Verwendung von Wartezeiten zwischen den Wiederholungen, die basierend auf der Anzahl der Fehler und der konfigurierten Backoff-Logik angepasst werden. Die Bibliothek ermöglicht eine einfache Anpassung der Backoff-Strategie.
exponential-backoff:
exponential-backoff implementiert die Backoff-Logik durch exponentielles Wachstum der Wartezeit zwischen den Wiederholungen. Die Implementierung ist einfach und effizient, ideal für Anwendungen, die eine klare und konsistente exponentielle Backoff-Strategie benötigen.
async-retry:
async-retry implementiert Backoff durch die Verwendung einer Wartezeit zwischen den Wiederholungen, die basierend auf der Anzahl der bereits durchgeführten Wiederholungen angepasst werden kann. Die Bibliothek unterstützt einfaches und exponentielles Backoff, wobei die Backoff-Logik intern verwaltet wird.
backoff:
backoff bietet eine umfassende Implementierung von Backoff-Strategien, die es Entwicklern ermöglicht, verschiedene Algorithmen auszuwählen und sogar benutzerdefinierte Backoff-Logik zu implementieren. Die Bibliothek ist flexibel und ermöglicht die Anpassung der Backoff-Parameter nach Bedarf.

Benutzerdefinierte Wiederholungsbedingungen

retry:
retry unterstützt die Implementierung benutzerdefinierter Wiederholungsbedingungen durch die Bereitstellung von Hooks und Konfigurationsoptionen, die es Entwicklern ermöglichen, die Wiederholungslogik nach ihren Bedürfnissen anzupassen.
promise-retry:
promise-retry ermöglicht die Definition benutzerdefinierter Wiederholungsbedingungen durch die Bereitstellung einer Funktion, die bestimmt, ob die Wiederholung basierend auf dem Fehler oder dem Ergebnis der Funktion erfolgen soll. Dies ermöglicht eine gezielte Wiederholung basierend auf spezifischen Bedingungen.
exponential-backoff:
exponential-backoff bietet keine integrierte Unterstützung für benutzerdefinierte Wiederholungsbedingungen, da sie sich auf die Implementierung der exponentiellen Backoff-Logik konzentriert. Entwickler müssten benutzerdefinierte Logik implementieren, um Wiederholungsbedingungen zu steuern.
async-retry:
async-retry ermöglicht die Definition benutzerdefinierter Wiederholungsbedingungen durch die Bereitstellung einer Funktion, die bestimmt, ob die Wiederholung basierend auf dem Fehler oder dem Ergebnis der Funktion erfolgen soll. Dies bietet Flexibilität bei der Handhabung spezifischer Fehler.
backoff:
backoff ermöglicht die Implementierung benutzerdefinierter Wiederholungsbedingungen, einschließlich der Möglichkeit, verschiedene Algorithmen und Logiken für die Wiederholung zu definieren. Die Bibliothek ist flexibel und unterstützt komplexe Wiederholungslogik.

Dokumentation und Community

retry:
retry bietet umfassende Dokumentation und Beispiele, die die vielseitigen Funktionen der Bibliothek erklären. Die Community ist groß, und die Bibliothek wird aktiv gewartet.
promise-retry:
promise-retry verfügt über eine gut dokumentierte API mit Beispielen, die die Verwendung der Bibliothek zur Wiederholung von Promise-basierten Operationen veranschaulichen. Die Community ist klein, aber aktiv.
exponential-backoff:
exponential-backoff bietet einfache Dokumentation, die sich auf die Implementierung der exponentiellen Backoff-Logik konzentriert. Die Bibliothek ist leichtgewichtig und hat eine kleine, aber engagierte Community.
async-retry:
async-retry verfügt über eine klare und gut strukturierte Dokumentation, die Beispiele und Anleitungen zur Verwendung der Bibliothek bietet. Die Community ist aktiv, und die Bibliothek wird regelmäßig gewartet.
backoff:
backoff bietet umfassende Dokumentation, die die verschiedenen Funktionen und Anpassungsmöglichkeiten der Bibliothek detailliert beschreibt. Die Community ist engagiert, und es gibt viele Ressourcen für Entwickler.

Ease of Use: Code Examples

retry:

Ein Beispiel für die Verwendung von retry, um eine Funktion mit Wiederholungen zu versehen:

const retry = require('retry');

function unreliableFunction(callback) {
  const shouldFail = Math.random() < 0.7;
  if (shouldFail) {
    callback(new Error('Fehler!'));
  } else {
    callback(null, 'Erfolg!');
  }
}

const operation = retry.operation({
  retries: 5,
  factor: 2,
  minTimeout: 1000,
  maxTimeout: 5000,
});

operation.attempt(currentAttempt => {
  console.log(`Versuch ${currentAttempt}`);
  unreliableFunction((err, result) => {
    if (operation.retry(err)) {
      console.log(`Wiederhole... (Versuch ${currentAttempt})`);
      return;
    }
    if (err) {
      console.error('Alle Wiederholungen fehlgeschlagen:', err);
    } else {
      console.log(result);
    }
  });
});

promise-retry:

Ein Beispiel für die Verwendung von promise-retry, um eine Promise-basierte Funktion mit Wiederholungen zu versehen:

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

function unreliablePromise() {
  return new Promise((resolve, reject) => {
    const shouldFail = Math.random() < 0.7;
    if (shouldFail) reject(new Error('Fehler!'));
    else resolve('Erfolg!');
  });
}

promiseRetry((retry, number) => {
  console.log(`Versuch ${number}`);
  return unreliablePromise().catch(retry);
}, {
  retries: 5,
  factor: 2,
  minTimeout: 1000,
  maxTimeout: 5000,
}).then(result => {
  console.log(result);
}).catch(error => {
  console.error('Alle Wiederholungen fehlgeschlagen:', error);
});

exponential-backoff:

Ein einfaches Beispiel für die Verwendung von exponential-backoff, um eine Funktion mit exponentiellem Backoff wiederholt aufzurufen:

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

function unreliableFunction() {
  return new Promise((resolve, reject) => {
    const shouldFail = Math.random() < 0.7;
    if (shouldFail) reject(new Error('Fehler!'));
    else resolve('Erfolg!');
  });
}

async function run() {
  try {
    const result = await backoff(() => unreliableFunction(), {
      maxAttempts: 5,
      initialDelay: 1000,
      multiplier: 2,
    });
    console.log(result);
  } catch (error) {
    console.error('Alle Wiederholungen fehlgeschlagen:', error);
  }
}

run();

async-retry:

Ein einfaches Beispiel für die Verwendung von async-retry, um eine fehlgeschlagene Funktion mit Wiederholungen zu versehen:

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

async function unreliableFunction() {
  // Simulieren Sie eine zufällige Fehlfunktion
  const shouldFail = Math.random() < 0.7;
  if (shouldFail) throw new Error('Fehler!');
  return 'Erfolg!';
}

async function run() {
  try {
    const result = await retry(unreliableFunction, {
      retries: 5,
      factor: 2,
      minTimeout: 1000,
      maxTimeout: 5000,
    });
    console.log(result);
  } catch (error) {
    console.error('Alle Wiederholungen fehlgeschlagen:', error);
  }
}

run();

backoff:

Ein Beispiel für die Verwendung von backoff, um eine Funktion mit benutzerdefinierter Backoff-Logik wiederholt aufzurufen:

const backoff = require('backoff');

const operation = backoff.call(function (callback) {
  // Simulieren Sie eine fehlgeschlagene Operation
  const shouldFail = Math.random() < 0.8;
  if (shouldFail) {
    console.log('Operation fehlgeschlagen, wiederhole...');
    callback(new Error('Fehler!'));
  } else {
    console.log('Operation erfolgreich!');
    callback(null, 'Erfolg!');
  }
});

operation.failAfter(5); // Maximal 5 Wiederholungen
operation.setStrategy(new backoff.ExponentialStrategy()); // Exponentielle Backoff-Strategie

operation.on('backoff', function (number, delay) {
  console.log(`Warte ${delay} ms vor der nächsten Wiederholung...`);
});

operation.on('success', function (result) {
  console.log('Operation abgeschlossen:', result);
});

operation.on('fail', function () {
  console.log('Alle Wiederholungen fehlgeschlagen.');
});

operation.start();