Definiert in: async-queuer.ts:271

Eine flexible asynchrone Warteschlange zur Verarbeitung von Aufgaben mit konfigurierbarer Nebenläufigkeit, Priorität und Ablaufzeit.

Merkmale

• Unterstützung für Prioritätswarteschlangen über die Option getPriority
• Konfigurierbare Nebenläufigkeitsgrenze
• Callbacks für erfolgreiche Aufgaben, Fehler, Abschluss und Änderungen des Warteschlangenstatus
• FIFO (First In First Out) oder LIFO (Last In First Out) Warteschlangenverhalten
• Verarbeitung pausieren und fortsetzen
• Aufgabenabbruch
• Ablauf von Elementen zur Entfernung veralteter Elemente aus der Warteschlange

Aufgaben werden bis zur konfigurierten Nebenläufigkeitsgrenze gleichzeitig verarbeitet. Wenn eine Aufgabe abgeschlossen ist, wird die nächste ausstehende Aufgabe verarbeitet, wenn die Nebenläufigkeitsgrenze dies zulässt.

Fehlerbehandlung

• Wenn ein onError Handler bereitgestellt wird, wird dieser mit dem Fehler und der Queuer-Instanz aufgerufen
• Wenn throwOnError auf true gesetzt ist (Standardwert, wenn kein onError-Handler bereitgestellt wird), wird der Fehler ausgelöst.
• Wenn throwOnError auf false gesetzt ist (Standardwert, wenn ein onError-Handler bereitgestellt wird), wird der Fehler "verschluckt".
• Sowohl onError als auch throwOnError können zusammen verwendet werden; der Handler wird aufgerufen, bevor ein Fehler ausgelöst wird
• Der Fehlerstatus kann mit der AsyncQueuer-Instanz überprüft werden

Zustandsverwaltung

• Verwendet TanStack Store für reaktives Zustandsmanagement
• Verwenden Sie initialState, um Anfangswerte für den Status bereitzustellen, wenn der asynchrone Queuer erstellt wird
• Verwenden Sie den onSuccess Callback, um auf erfolgreiche Aufgabenausführung zu reagieren und benutzerdefinierte Logik zu implementieren
• Verwenden Sie den onError Callback, um auf Fehler bei der Aufgabenausführung zu reagieren und benutzerdefinierte Fehlerbehandlung zu implementieren
• Verwenden Sie den onSettled Callback, um auf den Abschluss der Aufgabenausführung (Erfolg oder Fehler) zu reagieren und benutzerdefinierte Logik zu implementieren
• Verwenden Sie den onItemsChange Callback, um auf das Hinzufügen oder Entfernen von Elementen aus der Warteschlange zu reagieren
• Verwenden Sie den onExpire Callback, um auf abgelaufene Elemente zu reagieren und benutzerdefinierte Logik zu implementieren
• Verwenden Sie den onReject Callback, um auf abgelehnte Elemente zu reagieren, wenn die Warteschlange voll ist
• Der Status umfasst die Anzahl der Fehler, die Anzahl der abgelaufenen Elemente, die Anzahl der zurückgewiesenen Elemente, den laufenden Status sowie die Anzahl der erfolgreichen/abgeschlossenen Elemente
• Der Status kann über asyncQueuer.store.state abgerufen werden, wenn die Klasse direkt verwendet wird
• Bei Verwendung von Framework-Adaptern (React/Solid) wird der Status über asyncQueuer.state abgerufen

Beispielanwendung

const asyncQueuer = new AsyncQueuer<string>(async (item) => {
  // process item
  return item.toUpperCase();
}, {
  concurrency: 2,
  onSuccess: (result) => {
    console.log(result);
  }
});

asyncQueuer.addItem('hello');
asyncQueuer.start();

const asyncQueuer = new AsyncQueuer<string>(async (item) => {
  // process item
  return item.toUpperCase();
}, {
  concurrency: 2,
  onSuccess: (result) => {
    console.log(result);
  }
});

asyncQueuer.addItem('hello');
asyncQueuer.start();

• TValue

new AsyncQueuer<TValue>(fn, initialOptions): AsyncQueuer<TValue>

new AsyncQueuer<TValue>(fn, initialOptions): AsyncQueuer<TValue>

Definiert in: async-queuer.ts:279

(item) => Promise<any>

AsyncQueuerOptions<TValue> = {}

AsyncQueuer<TValue>

fn: (item) => Promise<any>;

fn: (item) => Promise<any>;

Definiert in: async-queuer.ts:280

TValue

Promise<any>

key: string;

key: string;

Definiert in: async-queuer.ts:275

options: AsyncQueuerOptions<TValue>;

options: AsyncQueuerOptions<TValue>;

Definiert in: async-queuer.ts:276

readonly store: Store<Readonly<AsyncQueuerState<TValue>>>;

readonly store: Store<Readonly<AsyncQueuerState<TValue>>>;

Definiert in: async-queuer.ts:272

addItem(
   item, 
   position, 
   runOnItemsChange): boolean

addItem(
   item, 
   position, 
   runOnItemsChange): boolean

Definiert in: async-queuer.ts:421

Fügt ein Element zur Warteschlange hinzu. Wenn die Warteschlange voll ist, wird das Element abgelehnt und onReject aufgerufen. Elemente können basierend auf der Priorität oder am Anfang/Ende basierend auf der Konfiguration eingefügt werden.

TValue

QueuePosition = ...

boolean = true

boolean

queuer.addItem({ value: 'task', priority: 10 });
queuer.addItem('task2', 'front');

queuer.addItem({ value: 'task', priority: 10 });
queuer.addItem('task2', 'front');

clear(): void

clear(): void

Definiert in: async-queuer.ts:734

Entfernt alle ausstehenden Elemente aus der Warteschlange. Beeinflusst keine aktiven Aufgaben.

void

execute(position?): Promise<any>

execute(position?): Promise<any>

Definiert in: async-queuer.ts:556

Entfernt und gibt das nächste Element aus der Warteschlange zurück und führt die Aufgabenfunktion damit aus.

QueuePosition

Promise<any>

queuer.execute();
// LIFO
queuer.execute('back');

queuer.execute();
// LIFO
queuer.execute('back');

flush(numberOfItems, position?): Promise<void>

flush(numberOfItems, position?): Promise<void>

Definiert in: async-queuer.ts:591

Verarbeitet eine angegebene Anzahl von Elementen, die sofort ohne Wartezeit ausgeführt werden sollen. Wenn keine numberOfItems angegeben ist, werden alle Elemente verarbeitet.

number = ...

QueuePosition

Promise<void>

flushAsBatch(batchFunction): Promise<void>

flushAsBatch(batchFunction): Promise<void>

Definiert in: async-queuer.ts:605

Verarbeitet alle Elemente in der Warteschlange als Stapel unter Verwendung der bereitgestellten Funktion als Argument. Die Warteschlange wird nach der Verarbeitung geleert.

(items) => Promise<any>

Promise<void>

getNextItem(position): undefined | TValue

getNextItem(position): undefined | TValue

Definiert in: async-queuer.ts:504

Entfernt und gibt das nächste Element aus der Warteschlange zurück, ohne die Aufgabenfunktion auszuführen. Verwenden Sie dies für die manuelle Warteschlangenverwaltung. Normalerweise verwenden Sie execute(), um Elemente zu verarbeiten.

QueuePosition = ...

undefined | TValue

// FIFO
queuer.getNextItem();
// LIFO
queuer.getNextItem('back');

// FIFO
queuer.getNextItem();
// LIFO
queuer.getNextItem('back');

peekActiveItems(): TValue[]

peekActiveItems(): TValue[]

Definiert in: async-queuer.ts:697

Gibt die aktuell verarbeiteten Elemente (aktive Aufgaben) zurück.

TValue[]

peekAllItems(): TValue[]

peekAllItems(): TValue[]

Definiert in: async-queuer.ts:690

Gibt eine Kopie aller Elemente in der Warteschlange zurück, einschließlich aktiver und ausstehender Elemente.

TValue[]

peekNextItem(position): undefined | TValue

peekNextItem(position): undefined | TValue

Definiert in: async-queuer.ts:680

Gibt das nächste Element in der Warteschlange zurück, ohne es zu entfernen.

QueuePosition = 'front'

undefined | TValue

queuer.peekNextItem(); // front
queuer.peekNextItem('back'); // back

queuer.peekNextItem(); // front
queuer.peekNextItem('back'); // back

peekPendingItems(): TValue[]

peekPendingItems(): TValue[]

Definiert in: async-queuer.ts:704

Gibt die auf die Verarbeitung wartenden Elemente (ausstehende Aufgaben) zurück.

TValue[]

reset(): void

reset(): void

Definiert in: async-queuer.ts:742

Setzt den Status des Queuers auf seine Standardwerte zurück

void

setOptions(newOptions): void

setOptions(newOptions): void

Definiert in: async-queuer.ts:318

Aktualisiert die Queuer-Optionen. Neue Optionen werden mit den bestehenden Optionen zusammengeführt.

Partial<AsyncQueuerOptions<TValue>>

void

start(): void

start(): void

Definiert in: async-queuer.ts:711

Startet die Verarbeitung von Elementen in der Warteschlange. Wenn bereits ausgeführt, tut dies nichts.

void

stop(): void

stop(): void

Definiert in: async-queuer.ts:721

Stoppt die Verarbeitung von Elementen in der Warteschlange. Leert die Warteschlange nicht.

void