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	143,690,534	2,471	11.5 kB	5	hace 2 días	MIT
async	60,260,738	28,226	808 kB	10	hace un año	MIT
bluebird	28,936,346	20,551	-	123	hace 6 años	MIT
promise-queue	929,263	230	-	10	hace 8 años	MIT
promise-limit	827,994	143	-	10	hace 7 años	ISC

Paquete

Descargas

Stars

Tamaño

Issues

Publicación

Licencia

p-limit

143,690,534

2,471

11.5 kB

hace 2 días

MIT

async

60,260,738

28,226

808 kB

hace un año

MIT

bluebird

28,936,346

20,551

123

hace 6 años

MIT

promise-queue

929,263

230

hace 8 años

MIT

promise-limit

827,994

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);