p-limit vs async vs bluebird vs promise-queue vs promise-limit | "JavaScript Promise ve Asenkron Yönetimi" npm Paketleri Karşılaştırması

Paket	İndirmeler	Stars	Boyut	Issues	Yayın Tarihi	Lisans

p-limit	163,140,208	2,509	11.7 kB	5	il y a 8 jours	MIT
async	68,237,246	28,221	808 kB	18	il y a un an	MIT
bluebird	32,446,753	20,580	-	123	il y a 6 ans	MIT
promise-queue	979,712	230	-	10	il y a 8 ans	MIT
promise-limit	860,431	143	-	10	il y a 7 ans	ISC

Paket

İndirmeler

Stars

Boyut

Issues

Yayın Tarihi

Lisans

p-limit

163,140,208

2,509

11.7 kB

il y a 8 jours

MIT

async

68,237,246

28,221

808 kB

il y a un an

MIT

bluebird

32,446,753

20,580

123

il y a 6 ans

MIT

promise-queue

979,712

230

il y a 8 ans

MIT

promise-limit

860,431

143

il y a 7 ans

ISC

Asenkron Yönetim

p-limit:
p-limit kütüphanesi, belirli bir asenkron işlemin aynı anda kaç kez çalışabileceğini sınırlamak için kullanılır. Bu, asenkron işlemlerin eşzamanlılığını kontrol etmeye yardımcı olur.
async:
async kütüphanesi, asenkron akışları yönetmek için bir dizi araç sunar. Paralel, seri ve sınırlı eşzamanlılık gibi farklı asenkron kontrol akışlarını destekler.
bluebird:
bluebird kütüphanesi, Promise tabanlı asenkron yönetim sağlar. Yüksek performanslı Promise'ler, paralel işlemler ve gelişmiş hata yönetimi gibi özellikler sunar.
promise-queue:
promise-queue kütüphanesi, asenkron işlemleri bir kuyrukta sıraya alarak yönetir. Her seferinde yalnızca belirli sayıda işlemin gerçekleştirilmesini sağlar.
promise-limit:
promise-limit kütüphanesi, Promise'lerin eşzamanlılığını sınırlamak için basit bir API sunar. Bu, kaynak kullanımını yönetmek için etkilidir.

Hata Yönetimi

p-limit:
p-limit kütüphanesi, hata yönetimi için özel bir mekanizma sağlamaz. Hatalar, asenkron fonksiyonlar içinde yönetilmelidir.
async:
async kütüphanesi, hata yönetimi için callback tabanlı bir yaklaşım kullanır. Hatalar, geri çağırma fonksiyonlarına iletilir.
bluebird:
bluebird kütüphanesi, Promise tabanlı hata yönetimi sağlar. Hatalar, catch metoduyla yakalanabilir ve yönetilebilir.
promise-queue:
promise-queue kütüphanesi, hata yönetimi için bir mekanizma sağlamaz. Hatalar, kuyrukta sıraya alınan asenkron işlemler içinde yönetilmelidir.
promise-limit:
promise-limit kütüphanesi, hata yönetimi için basit bir yaklaşım sunar. Hatalar, Promise yapısı aracılığıyla iletilir.

Performans

p-limit:
p-limit kütüphanesi, asenkron işlemlerin eşzamanlılığını sınırlayarak sistem kaynaklarını korur. Bu, aşırı yüklenmeyi önlemeye yardımcı olur.
async:
async kütüphanesi, performans açısından verimlidir ancak karmaşık asenkron akışları yönetirken ek overhead oluşturabilir.
bluebird:
bluebird kütüphanesi, yüksek performanslı Promise'ler sunar. Özellikle büyük ölçekli asenkron işlemler için optimize edilmiştir.
promise-queue:
promise-queue kütüphanesi, asenkron işlemleri bir kuyrukta sıraya alarak yönetir. Bu, işlemlerin daha düzenli ve kontrol edilebilir bir şekilde gerçekleştirilmesini sağlar.
promise-limit:
promise-limit kütüphanesi, Promise'lerin eşzamanlılığını sınırlayarak kaynak kullanımını yönetir. Basit bir API ile etkili bir şekilde çalışır.

Kullanım Senaryoları

p-limit:
p-limit kütüphanesi, belirli bir asenkron işlemin eşzamanlılığını sınırlamak için kullanılır. Bu, API çağrıları veya veri tabanı işlemleri gibi senaryolar için yararlıdır.
async:
async kütüphanesi, karmaşık asenkron akışları yönetmek için idealdir. Paralel ve seri işlemleri bir arada yönetmek için kullanılabilir.
bluebird:
bluebird kütüphanesi, yüksek performans gerektiren asenkron işlemler için uygundur. Özellikle büyük veri setleri ile çalışırken avantaj sağlar.
promise-queue:
promise-queue kütüphanesi, asenkron işlemleri sırayla gerçekleştirmek için uygundur. Özellikle kaynakları sınırlı olan sistemlerde etkilidir.
promise-limit:
promise-limit kütüphanesi, basit ve hafif bir çözüm arayanlar için idealdir. Eşzamanlılık sınırlandırması gerektiren her türlü asenkron işlem için kullanılabilir.

Örnek Kod

p-limit:

p-limit kütüphanesi ile eşzamanlılık sınırlandırma

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

const limit = pLimit(2); // Aynı anda en fazla 2 işlem

const işlemler = [
  limit(() => new Promise((resolve) => setTimeout(() => resolve('İşlem 1'), 1000))),
  limit(() => new Promise((resolve) => setTimeout(() => resolve('İşlem 2'), 500))),
  limit(() => new Promise((resolve) => setTimeout(() => resolve('İşlem 3'), 2000)))
];

Promise.all(işlemler).then((sonuçlar) => {
  console.log('Sınırlı Eşzamanlı Sonuçlar:', sonuçlar);
});

async:

async kütüphanesi ile asenkron işlemler

const async = require('async');

// Paralel işlemler
async.parallel([
  (callback) => setTimeout(() => callback(null, 'İşlem 1'), 1000),
  (callback) => setTimeout(() => callback(null, 'İşlem 2'), 500)
], (err, sonuçlar) => {
  if (err) throw err;
  console.log('Paralel Sonuçlar:', sonuçlar);
});

// Seri işlemler
async.series([
  (callback) => setTimeout(() => callback(null, 'İşlem 1'), 1000),
  (callback) => setTimeout(() => callback(null, 'İşlem 2'), 500)
], (err, sonuçlar) => {
  if (err) throw err;
  console.log('Seri Sonuçlar:', sonuçlar);
});

// Sınırlı eşzamanlılık
async.eachLimit([1, 2, 3], 2, (num, callback) => {
  setTimeout(() => {
    console.log('İşlem:', num);
    callback();
  }, 1000);
}, (err) => {
  if (err) throw err;
  console.log('Tüm işlemler tamamlandı.');
});

bluebird:

bluebird kütüphanesi ile Promise yönetimi

const Bluebird = require('bluebird');

// Yüksek performanslı Promise
const promise1 = Bluebird.resolve('İlk Promise');
promise1.then((değer) => {
  console.log(değer);
});

// Paralel işlemler
const promise2 = Bluebird.all([
  Bluebird.resolve('İşlem 1'),
  Bluebird.resolve('İşlem 2')
]);
promise2.then((sonuçlar) => {
  console.log('Paralel Sonuçlar:', sonuçlar);
});

// Hata yönetimi
const promise3 = Bluebird.reject('Hata!');
promise3.catch((hata) => {
  console.error('Yakalanan Hata:', hata);
});

promise-queue:

promise-queue kütüphanesi ile kuyruk yönetimi

const PromiseQueue = require('promise-queue');
const kuyruk = new PromiseQueue(2, Infinity); // Aynı anda en fazla 2 işlem

const işlemler = [
  () => new Promise((resolve) => setTimeout(() => resolve('İşlem 1'), 1000)),
  () => new Promise((resolve) => setTimeout(() => resolve('İşlem 2'), 500)),
  () => new Promise((resolve) => setTimeout(() => resolve('İşlem 3'), 2000))
];

const sonuçlar = işlemler.map((işlem) => kuyruk.add(işlem));
Promise.all(sonuçlar).then((değerler) => {
  console.log('Kuyruk Sonuçları:', değerler);
});

promise-limit:

promise-limit kütüphanesi ile basit eşzamanlılık sınırlandırma

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

const limit = promiseLimit(2); // Aynı anda en fazla 2 işlem

const işlemler = [
  limit(() => new Promise((resolve) => setTimeout(() => resolve('İşlem 1'), 1000))),
  limit(() => new Promise((resolve) => setTimeout(() => resolve('İşlem 2'), 500))),
  limit(() => new Promise((resolve) => setTimeout(() => resolve('İşlem 3'), 2000)))
];

Promise.all(işlemler).then((sonuçlar) => {
  console.log('Sınırlı Eşzamanlı Sonuçlar:', sonuçlar);
});