Definiert in: queuer.ts:255

Eine flexible Warteschlange, die Elemente mit konfigurierbaren Wartezeiten, Verfallszeiten und Prioritäten verarbeitet.

Merkmale

• Automatische oder manuelle Verarbeitung von Elementen
• FIFO (First In First Out), LIFO (Last In First Out) oder Double-Ended-Queue-Verhalten
• Prioritätsbasierte Sortierung, wenn getPriority bereitgestellt wird
• Verfallszeit von Elementen und Entfernung veralteter Elemente
• Callbacks für Warteschlangenstatusänderungen, Ausführung, Ablehnung und Verfall

Ausführungsverhalten

• start(): Beginnt mit der automatischen Verarbeitung von Elementen in der Warteschlange (Standard: isRunning)
• stop(): Pausiert die Verarbeitung, behält aber den Zustand der Warteschlange bei
• wait: Konfigurierbare Verzögerung zwischen der Verarbeitung von Elementen
• onItemsChange/onExecute: Callbacks zur Überwachung des Warteschlangenstatus

Manuelle Verarbeitung wird ebenfalls unterstützt, wenn die automatische Verarbeitung deaktiviert ist

• execute(): Verarbeitet das nächste Element mithilfe der bereitgestellten Funktion
• getNextItem(): Entfernt und gibt das nächste Element ohne Verarbeitung zurück

Das Verhalten der Warteschlange ist standardmäßig FIFO

• addItem(item): Fügt das Element am Ende der Warteschlange hinzu
• Elemente werden von vorne aus der Warteschlange verarbeitet

Prioritätswarteschlange

• Stellen Sie eine getPriority Funktion bereit; höhere Werte werden zuerst verarbeitet

Stapel (LIFO)

• addItem(item, 'back'): Fügt das Element am Ende hinzu
• getNextItem('back'): Entfernt das Element vom Ende

Doppelt endende Warteschlange

• addItem(item, position): Fügt das Element an der angegebenen Position hinzu ('front'/'back')
• getNextItem(position): Entfernt das Element von der angegebenen Position

Elementverfall

• expirationDuration: Maximale Zeit, die Elemente in der Warteschlange verbleiben können
• getIsExpired: Funktion zur Überschreibung des Standardverfalls
• onExpire: Callback für abgelaufene Elemente

Zustandsverwaltung

• Verwendet TanStack Store für reaktives Zustandsmanagement
• Verwenden Sie initialState, um anfängliche Zustandswerte bei der Erstellung des Queuers bereitzustellen
• Verwenden Sie den onExecute Callback, um auf die Ausführung von Elementen 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 Ausführungsanzahl, Verfallsanzahl, Ablehnungsanzahl und isRunning-Status
• Der Status kann über queuer.store.state abgerufen werden, wenn die Klasse direkt verwendet wird
• Bei Verwendung von Framework-Adaptern (React/Solid) wird der Status von queuer.state abgerufen

Beispielanwendung

// Auto-processing queue with wait time
const autoQueue = new Queuer<number>((n) => console.log(n), {
  started: true, // Begin processing immediately
  wait: 1000, // Wait 1s between items
  onExecute: (item, queuer) => console.log(`Processed ${item}`)
});
autoQueue.addItem(1); // Will process after 1s
autoQueue.addItem(2); // Will process 1s after first item

// Manual processing queue
const manualQueue = new Queuer<number>((n) => console.log(n), {
  started: false
});
manualQueue.addItem(1); // [1]
manualQueue.addItem(2); // [1, 2]
manualQueue.execute(); // logs 1, queue is [2]
manualQueue.getNextItem(); // returns 2, queue is empty

// Auto-processing queue with wait time
const autoQueue = new Queuer<number>((n) => console.log(n), {
  started: true, // Begin processing immediately
  wait: 1000, // Wait 1s between items
  onExecute: (item, queuer) => console.log(`Processed ${item}`)
});
autoQueue.addItem(1); // Will process after 1s
autoQueue.addItem(2); // Will process 1s after first item

// Manual processing queue
const manualQueue = new Queuer<number>((n) => console.log(n), {
  started: false
});
manualQueue.addItem(1); // [1]
manualQueue.addItem(2); // [1, 2]
manualQueue.execute(); // logs 1, queue is [2]
manualQueue.getNextItem(); // returns 2, queue is empty

• TValue

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

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

Definiert in: queuer.ts:263

(item) => void

QueuerOptions<TValue> = {}

Queuer<TValue>

fn: (item) => void;

fn: (item) => void;

Definiert in: queuer.ts:264

TValue

void

key: string;

key: string;

Definiert in: queuer.ts:259

options: QueuerOptions<TValue>;

options: QueuerOptions<TValue>;

Definiert in: queuer.ts:260

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

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

Definiert in: queuer.ts:256

addItem(
   item, 
   position, 
   runOnItemsChange): boolean

addItem(
   item, 
   position, 
   runOnItemsChange): boolean

Definiert in: queuer.ts:384

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.

Gibt true zurück, wenn das Element hinzugefügt wurde, false, wenn die Warteschlange voll ist.

Beispielanwendung

queuer.addItem('task');
queuer.addItem('task2', 'front');

queuer.addItem('task');
queuer.addItem('task2', 'front');

TValue

QueuePosition = ...

boolean = true

boolean

clear(): void

clear(): void

Definiert in: queuer.ts:666

Entfernt alle ausstehenden Elemente aus der Warteschlange. Betrifft keine Elemente, die gerade verarbeitet werden.

void

execute(position?): undefined | TValue

execute(position?): undefined | TValue

Definiert in: queuer.ts:520

Entfernt und gibt das nächste Element aus der Warteschlange zurück und verarbeitet es mit der bereitgestellten Funktion.

Beispielanwendung

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

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

QueuePosition

undefined | TValue

flush(numberOfItems, position?): void

flush(numberOfItems, position?): void

Definiert in: queuer.ts:536

Verarbeitet eine bestimmte Anzahl von Elementen, um sie sofort ohne Wartezeit auszuführen. Wenn keine numberOfItems angegeben ist, werden alle Elemente verarbeitet.

number = ...

QueuePosition

void

flushAsBatch(batchFunction): void

flushAsBatch(batchFunction): void

Definiert in: queuer.ts:551

Verarbeitet alle Elemente in der Warteschlange als Stapel mithilfe der bereitgestellten Funktion als Argument. Die Warteschlange wird nach der Verarbeitung gelöscht.

(items) => void

void

getNextItem(position): undefined | TValue

getNextItem(position): undefined | TValue

Definiert in: queuer.ts:468

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

Beispielanwendung

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

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

QueuePosition = ...

undefined | TValue

peekAllItems(): TValue[]

peekAllItems(): TValue[]

Definiert in: queuer.ts:634

Gibt eine Kopie aller Elemente in der Warteschlange zurück.

TValue[]

peekNextItem(position): undefined | TValue

peekNextItem(position): undefined | TValue

Definiert in: queuer.ts:624

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

Beispielanwendung

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

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

QueuePosition = 'front'

undefined | TValue

reset(): void

reset(): void

Definiert in: queuer.ts:674

Setzt den Zustand des Queuers auf seine Standardwerte zurück

void

setOptions(newOptions): void

setOptions(newOptions): void

Definiert in: queuer.ts:300

Aktualisiert die Optionen des Queuers. Neue Optionen werden mit den vorhandenen Optionen zusammengeführt.

Partial<QueuerOptions<TValue>>

void

start(): void

start(): void

Definiert in: queuer.ts:641

Startet die Verarbeitung von Elementen in der Warteschlange. Wenn bereits isRunning, tut es nichts.

void

stop(): void

stop(): void

Definiert in: queuer.ts:651

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

void