p-limit vs async vs bluebird vs promise-queue vs promise-limit | "Verwaltung von asynchronen Vorgängen in JavaScript" npm-Pakete Vergleich

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

p-limit	143,690,534	2,471	11.5 kB	5	vor 2 Tagen	MIT
async	60,260,738	28,226	808 kB	10	vor einem Jahr	MIT
bluebird	28,936,346	20,551	-	123	vor 6 Jahren	MIT
promise-queue	929,263	230	-	10	vor 8 Jahren	MIT
promise-limit	827,994	143	-	10	vor 7 Jahren	ISC

Paket

Downloads

Stars

Größe

Issues

Veröffentlichung

Lizenz

p-limit

143,690,534

2,471

11.5 kB

vor 2 Tagen

MIT

async

60,260,738

28,226

808 kB

vor einem Jahr

MIT

bluebird

28,936,346

20,551

123

vor 6 Jahren

MIT

promise-queue

929,263

230

vor 8 Jahren

MIT

promise-limit

827,994

143

vor 7 Jahren

ISC

Concurrency Control

p-limit:
p-limit ist speziell für die Begrenzung der Anzahl der gleichzeitig ausgeführten Promises konzipiert. Es bietet eine einfache API, um die Parallelität mit minimalem Overhead zu steuern.
async:
async bietet umfassende Steuerung der Parallelität mit Funktionen wie async.eachLimit, async.mapLimit und async.queue, die es Entwicklern ermöglichen, die Anzahl der gleichzeitig ausgeführten Aufgaben genau zu steuern.
bluebird:
bluebird bietet keine integrierte Parallelitätskontrolle, aber Entwickler können Funktionen wie Promise.map mit dem concurrency-Parameter verwenden, um die Anzahl der gleichzeitig verarbeiteten Promises zu begrenzen.
promise-queue:
promise-queue steuert die Parallelität, indem es sicherstellt, dass Promises in der Reihenfolge ausgeführt werden, in der sie hinzugefügt wurden, wobei jeweils nur ein Promise gleichzeitig ausgeführt wird.
promise-limit:
promise-limit bietet eine einfache Möglichkeit, die gleichzeitige Ausführung von Promises zu begrenzen, hat jedoch keine erweiterten Funktionen oder Konfigurationsoptionen.

Performance

p-limit:
p-limit hat einen geringen Overhead und ist sehr effizient beim Begrenzen der Parallelität, was die Leistung bei Aufgaben verbessert, die von einer kontrollierten Anzahl gleichzeitiger Ausführungen profitieren.
async:
async ist leistungsfähig, kann jedoch bei übermäßiger Nutzung von Funktionen wie async.series oder async.waterfall zu Leistungsproblemen führen, insbesondere bei großen Datenmengen oder vielen Aufgaben.
bluebird:
bluebird ist eine der schnellsten Promise-Implementierungen und bietet optimierte Methoden für die Verarbeitung von Promises, was die Leistung bei umfangreichen asynchronen Operationen erheblich verbessert.
promise-queue:
promise-queue kann bei der Verarbeitung großer Mengen von Promises langsamer sein, da es sicherstellt, dass jeweils nur ein Promise ausgeführt wird, was die Gesamtzeit verlängern kann.
promise-limit:
promise-limit ist leichtgewichtig und verursacht nur minimalen Overhead, wenn es um die Begrenzung der gleichzeitigen Ausführung von Promises geht.

Error Handling

p-limit:
p-limit behandelt Fehler, die in den Promises auftreten, leitet sie jedoch nicht automatisch weiter oder bietet spezielle Fehlerbehandlungsfunktionen.
async:
async bietet integrierte Fehlerbehandlung mit Rückruffunktionen und unterstützt die Verwendung von try/catch in asynchronen Funktionen, um Fehler während der Ausführung zu erfassen.
bluebird:
bluebird bietet erweiterte Fehlerbehandlungsfunktionen, einschließlich der Möglichkeit, Fehler zu stornieren, Fortschrittsrückrufe zu verwenden und mehrere Fehler gleichzeitig zu behandeln.
promise-queue:
promise-queue stellt sicher, dass Fehler in den Promises in der Reihenfolge behandelt werden, in der sie ausgeführt werden, und ermöglicht eine geordnete Fehlerbehandlung.
promise-limit:
promise-limit behandelt Fehler in Promises auf die gleiche Weise wie native JavaScript-Promises, bietet jedoch keine speziellen Funktionen zur Fehlerbehandlung.

Ease of Use: Code Examples

p-limit:

Ein einfaches Beispiel für die Verwendung von p-limit, um die Anzahl der gleichzeitig ausgeführten Promises zu begrenzen:

const pLimit = require('p-limit');

const limit = pLimit(2);
const tasks = Array.from({ length: 5 }, (_, i) =>
  limit(() => new Promise((resolve) => {
    setTimeout(() => {
      console.log(`Aufgabe ${i + 1} abgeschlossen`);
      resolve();
    }, (i + 1) * 1000);
  }))
);

Promise.all(tasks).then(() => {
  console.log('Alle Aufgaben abgeschlossen.');
});

async:

Ein einfaches Beispiel für die Verwendung von async zur Durchführung von Aufgaben mit begrenzter Parallelität:

const async = require('async');

const tasks = [
  (callback) => setTimeout(() => { console.log('Task 1'); callback(); }, 1000),
  (callback) => setTimeout(() => { console.log('Task 2'); callback(); }, 500),
  (callback) => setTimeout(() => { console.log('Task 3'); callback(); }, 2000),
];

async.eachLimit(tasks, 2, (task, callback) => task(callback), (err) => {
  if (err) console.error('Error:', err);
  console.log('Alle Aufgaben abgeschlossen.');
});

bluebird:

Ein Beispiel für die Verwendung von bluebird zur Verarbeitung von Promises mit Fehlerbehandlung:

const Promise = require('bluebird');

const asyncTask = (time, shouldFail) => {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      if (shouldFail) reject('Fehler bei der Aufgabe');
      else resolve(`Aufgabe abgeschlossen nach ${time} ms`);
    }, time);
  });
};

Promise.all([
  asyncTask(1000, false),
  asyncTask(500, false),
  asyncTask(2000, true),
]).then((results) => {
  console.log(results);
}).catch((error) => {
  console.error('Fehler:', error);
});

promise-queue:

Ein Beispiel für die Verwendung von promise-queue, um eine Warteschlange für die Ausführung von Promises zu erstellen:

const PromiseQueue = require('promise-queue');
const queue = new PromiseQueue(1, Infinity);

const tasks = Array.from({ length: 5 }, (_, i) =>
  queue.add(() => new Promise((resolve) => {
    setTimeout(() => {
      console.log(`Aufgabe ${i + 1} abgeschlossen`);
      resolve();
    }, (i + 1) * 1000);
  }))
);

Promise.all(tasks).then(() => {
  console.log('Alle Aufgaben abgeschlossen.');
});

promise-limit:

Ein einfaches Beispiel für die Verwendung von promise-limit, um die gleichzeitige Ausführung von Promises zu begrenzen:

const promiseLimit = require('promise-limit');
const limit = promiseLimit(2);

const tasks = Array.from({ length: 5 }, (_, i) =>
  limit(() => new Promise((resolve) => {
    setTimeout(() => {
      console.log(`Aufgabe ${i + 1} abgeschlossen`);
      resolve();
    }, (i + 1) * 1000);
  }))
);

Promise.all(tasks).then(() => {
  console.log('Alle Aufgaben abgeschlossen.');
});