p-limit vs async vs bluebird vs promise-queue vs promise-limit | Comparación de paquetes npm de "Manejo de Promesas y Concurrencia"

Paquete	Descargas	Stars	Tamaño	Issues	Publicación	Licencia

p-limit	163,140,208	2,509	11.7 kB	5	hace 8 días	MIT
async	68,237,246	28,221	808 kB	18	hace un año	MIT
bluebird	32,446,753	20,580	-	123	hace 6 años	MIT
promise-queue	979,712	230	-	10	hace 8 años	MIT
promise-limit	860,431	143	-	10	hace 7 años	ISC

Paquete

Descargas

Stars

Tamaño

Issues

Publicación

Licencia

p-limit

163,140,208

2,509

11.7 kB

hace 8 días

MIT

async

68,237,246

28,221

808 kB

hace un año

MIT

bluebird

32,446,753

20,580

123

hace 6 años

MIT

promise-queue

979,712

230

hace 8 años

MIT

promise-limit

860,431

143

hace 7 años

ISC

Manejo de Promesas

p-limit:
p-limit no maneja promesas por sí misma, sino que limita la cantidad de promesas que se pueden ejecutar en paralelo, lo que ayuda a controlar la carga en operaciones asíncronas.
async:
async proporciona un manejo de promesas flexible que admite tanto el estilo de callback como el de promesas. Permite la integración de ambos enfoques, lo que facilita la transición entre ellos.
bluebird:
bluebird se centra en mejorar el manejo de promesas en JavaScript, ofreciendo un rendimiento superior y características avanzadas como la cancelación de promesas y un manejo de errores más detallado.
promise-queue:
promise-queue garantiza que las promesas se resuelvan en el orden en que se agregan, lo que permite un control preciso sobre la ejecución de tareas asíncronas.
promise-limit:
promise-limit es una biblioteca simple que limita la concurrencia de las promesas, asegurando que solo un número específico de promesas se resuelva al mismo tiempo.

Limitación de Concurrencia

p-limit:
p-limit es una biblioteca dedicada a limitar la concurrencia de las promesas, permitiendo establecer un límite en el número de promesas que se ejecutan simultáneamente.
async:
async ofrece varias funciones para limitar la concurrencia, como async.eachLimit y async.mapLimit, que permiten controlar cuántas tareas se ejecutan al mismo tiempo.
bluebird:
bluebird proporciona la limitación de concurrencia a través de su método Promise.map y Promise.each, donde se puede especificar el número máximo de promesas que se ejecutan en paralelo.
promise-queue:
promise-queue no limita la concurrencia, pero garantiza que las promesas se resuelvan en el orden en que se agregan, lo que permite un control más estricto sobre la ejecución de tareas.
promise-limit:
promise-limit es una biblioteca simple que limita la concurrencia de las promesas, asegurando que solo un número específico de promesas se resuelva al mismo tiempo.

Orden de Ejecución

p-limit:
p-limit no garantiza el orden de ejecución, ya que limita la concurrencia pero permite que las promesas se resuelvan en el orden en que se completan.
async:
async permite un control flexible sobre el orden de ejecución de las tareas, especialmente cuando se utilizan funciones como async.series y async.parallel.
bluebird:
bluebird mantiene el orden de ejecución de las promesas, pero permite la ejecución paralela si se especifica, lo que puede afectar el orden si no se maneja correctamente.
promise-queue:
promise-queue garantiza que las promesas se resuelvan en el orden en que se agregan, lo que permite un control preciso sobre la ejecución de tareas asíncronas.
promise-limit:
promise-limit no garantiza el orden de ejecución, ya que limita la concurrencia pero permite que las promesas se resuelvan en el orden en que se completan.

Ejemplo de Código

p-limit:

Ejemplo de limitación de concurrencia con p-limit:

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

const limit = pLimit(2);
const tareas = [
  () => new Promise((resolve) => setTimeout(() => { console.log('Tarea 1'); resolve(); }, 1000)),
  () => new Promise((resolve) => setTimeout(() => { console.log('Tarea 2'); resolve(); }, 500)),
  () => new Promise((resolve) => setTimeout(() => { console.log('Tarea 3'); resolve(); }, 2000)),
];

const tareasLimitadas = tareas.map((tarea) => limit(tarea));
Promise.all(tareasLimitadas);

async:

Ejemplo de limitación de concurrencia con async:

const async = require('async');

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

async.eachLimit(tareas, 2, (tarea, callback) => {
  tarea(callback);
});

bluebird:

Ejemplo de limitación de concurrencia con bluebird:

const Promise = require('bluebird');

const tareas = [
  () => new Promise((resolve) => setTimeout(() => { console.log('Tarea 1'); resolve(); }, 1000)),
  () => new Promise((resolve) => setTimeout(() => { console.log('Tarea 2'); resolve(); }, 500)),
  () => new Promise((resolve) => setTimeout(() => { console.log('Tarea 3'); resolve(); }, 2000)),
];

Promise.map(tareas, (tarea) => tarea(), { concurrency: 2 });

promise-queue:

Ejemplo de cola de promesas con promise-queue:

const Queue = require('promise-queue');
const queue = new Queue(2); // Limitar a 2 tareas en paralelo

const tareas = [
  () => new Promise((resolve) => setTimeout(() => { console.log('Tarea 1'); resolve(); }, 1000)),
  () => new Promise((resolve) => setTimeout(() => { console.log('Tarea 2'); resolve(); }, 500)),
  () => new Promise((resolve) => setTimeout(() => { console.log('Tarea 3'); resolve(); }, 2000)),
];

const promesas = tareas.map((tarea) => queue.add(tarea));
Promise.all(promesas);

promise-limit:

Ejemplo de limitación de concurrencia con promise-limit:

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

const limit = promiseLimit(2);
const tareas = [
  () => new Promise((resolve) => setTimeout(() => { console.log('Tarea 1'); resolve(); }, 1000)),
  () => new Promise((resolve) => setTimeout(() => { console.log('Tarea 2'); resolve(); }, 500)),
  () => new Promise((resolve) => setTimeout(() => { console.log('Tarea 3'); resolve(); }, 2000)),
];

const tareasLimitadas = tareas.map((tarea) => limit(tarea()));
Promise.all(tareasLimitadas);