Definiert in: async-rate-limiter.ts:216

Eine Klasse, die eine asynchrone, ratenbegrenzte Funktion erstellt.

Ratenbegrenzung ist ein einfacher Ansatz, der es einer Funktion ermöglicht, bis zu einem bestimmten Limit innerhalb eines Zeitfensters ausgeführt zu werden, und dann alle nachfolgenden Aufrufe blockiert, bis das Fenster abgelaufen ist. Dies kann zu "bursty" Verhalten führen, bei dem alle Ausführungen sofort erfolgen, gefolgt von einer vollständigen Blockierung.

Der Ratenbegrenzer unterstützt zwei Arten von Fenstern

• 'fixed': Ein striktes Fenster, das nach Ablauf des Zeitfensters zurückgesetzt wird. Alle Ausführungen innerhalb des Fensters zählen für das Limit, und das Fenster wird nach Ablauf der Periode vollständig zurückgesetzt.
• 'sliding': Ein rollierendes Fenster, das Ausführungen ermöglicht, sobald ältere abgelaufen sind. Dies sorgt für eine konsistentere Ausführungsrate im Laufe der Zeit.

Im Gegensatz zum nicht-asynchronen RateLimiter unterstützt diese asynchrone Version das Zurückgeben von Werten aus der ratenbegrenzten Funktion, was sie ideal für API-Aufrufe und andere asynchrone Operationen macht, bei denen Sie das Ergebnis des Aufrufs maybeExecute anstelle der Festlegung des Ergebnisses in einer Zustandsvariablen innerhalb der ratenbegrenzten Funktion wünschen.

Für reibungslosere Ausführungsmuster sollten Sie erwägen:

• Throttling: Sorgt für einen gleichmäßigen Abstand zwischen den Ausführungen (z. B. maximal einmal alle 200 ms)
• Debouncing: Wartet auf eine Pause bei den Aufrufen, bevor er ausgeführt wird (z. B. nach 500 ms ohne Aufrufe)

Ratenbegrenzung eignet sich am besten für harte API-Limits oder Ressourcenbeschränkungen. Für UI-Updates oder das Glätten häufiger Ereignisse bieten Throttling oder Debouncing normalerweise eine bessere Benutzererfahrung.

Zustandsverwaltung

• Verwendet TanStack Store für reaktives Zustandsmanagement
• Verwenden Sie initialState, um Anfangswerte für den Zustand bei der Erstellung des Ratenbegrenzers bereitzustellen
• initialState kann ein partielles Zustandsobjekt sein
• Verwenden Sie den Callback onSuccess, um auf die erfolgreiche Ausführung der Funktion zu reagieren und benutzerdefinierte Logik zu implementieren
• Verwenden Sie den Callback onError, um auf Fehler bei der Ausführung der Funktion zu reagieren und benutzerdefiniertes Fehlerhandling zu implementieren
• Verwenden Sie den Callback onSettled, um auf den Abschluss der Ausführung der Funktion (Erfolg oder Fehler) zu reagieren und benutzerdefinierte Logik zu implementieren
• Verwenden Sie den Callback onReject, um auf zurückgewiesene Ausführungen zu reagieren, wenn das Ratenlimit überschritten wird
• Der Zustand umfasst Ausführungszeiten, Erfolgs-/Fehlerzähler und den aktuellen Ausführungsstatus
• Der Zustand kann über asyncRateLimiter.store.state abgerufen werden, wenn die Klasse direkt verwendet wird
• Bei Verwendung von Framework-Adaptern (React/Solid) wird der Zustand aus asyncRateLimiter.state abgerufen

Fehlerbehandlung

• Wenn ein onError-Handler bereitgestellt wird, wird dieser mit dem Fehler und der Ratenbegrenzerinstanz 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 Fehlerzustand kann mit der zugrunde liegenden AsyncRateLimiter-Instanz überprüft werden
• Ratenlimit-Zurückweisungen (wenn das Limit überschritten wird) werden getrennt von Ausführungsfehlern über den onReject-Handler behandelt

const rateLimiter = new AsyncRateLimiter(
  async (id: string) => await api.getData(id),
  {
    limit: 5,
    window: 1000,
    windowType: 'sliding',
    onError: (error) => {
      console.error('API call failed:', error);
    },
    onReject: (limiter) => {
      console.log(`Rate limit exceeded. Try again in ${limiter.getMsUntilNextWindow()}ms`);
    }
  }
);

// Will execute immediately until limit reached, then block
// Returns the API response directly
const data = await rateLimiter.maybeExecute('123');

const rateLimiter = new AsyncRateLimiter(
  async (id: string) => await api.getData(id),
  {
    limit: 5,
    window: 1000,
    windowType: 'sliding',
    onError: (error) => {
      console.error('API call failed:', error);
    },
    onReject: (limiter) => {
      console.log(`Rate limit exceeded. Try again in ${limiter.getMsUntilNextWindow()}ms`);
    }
  }
);

// Will execute immediately until limit reached, then block
// Returns the API response directly
const data = await rateLimiter.maybeExecute('123');

• TFn erbt von AnyAsyncFunction

new AsyncRateLimiter<TFn>(fn, initialOptions): AsyncRateLimiter<TFn>

new AsyncRateLimiter<TFn>(fn, initialOptions): AsyncRateLimiter<TFn>

Definiert in: async-rate-limiter.ts:224

TFn

AsyncRateLimiterOptions<TFn>

AsyncRateLimiter<TFn>

fn: TFn;

fn: TFn;

Definiert in: async-rate-limiter.ts:225

key: string;

key: string;

Definiert in: async-rate-limiter.ts:220

options: AsyncRateLimiterOptions<TFn>;

options: AsyncRateLimiterOptions<TFn>;

Definiert in: async-rate-limiter.ts:221

readonly store: Store<Readonly<AsyncRateLimiterState<TFn>>>;

readonly store: Store<Readonly<AsyncRateLimiterState<TFn>>>;

Definiert in: async-rate-limiter.ts:217

getMsUntilNextWindow(): number

getMsUntilNextWindow(): number

Definiert in: async-rate-limiter.ts:457

Gibt die Anzahl der Millisekunden bis zur nächsten möglichen Ausführung zurück. Für feste Fenster ist dies die Zeit bis zum Zurücksetzen des aktuellen Fensters. Für rollierende Fenster ist dies die Zeit bis zum Ablauf der ältesten Ausführung.

number

getRemainingInWindow(): number

getRemainingInWindow(): number

Definiert in: async-rate-limiter.ts:447

Gibt die Anzahl der verbleibenden erlaubten Ausführungen im aktuellen Fenster zurück.

number

maybeExecute(...args): Promise<undefined | ReturnType<TFn>>

maybeExecute(...args): Promise<undefined | ReturnType<TFn>>

Definiert in: async-rate-limiter.ts:322

Versucht, die ratenbegrenzte Funktion auszuführen, wenn sie innerhalb der konfigurierten Grenzen liegt. Die Ausführung wird zurückgewiesen, wenn die Anzahl der Aufrufe im aktuellen Fenster das Limit überschreitet.

Fehlerbehandlung

• Wenn die ratenbegrenzte Funktion einen Fehler auslöst und kein onError-Handler konfiguriert ist, wird der Fehler von dieser Methode ausgelöst.
• Wenn ein onError-Handler konfiguriert ist, werden Fehler abgefangen und an den Handler übergeben, und diese Methode gibt undefined zurück.
• Der Fehlerzustand kann mit getErrorCount() und getIsExecuting() überprüft werden.

...Parameters<TFn>

Promise<undefined | ReturnType<TFn>>

Ein Promise, das mit dem Rückgabewert der Funktion aufgelöst wird oder undefined, wenn ein Fehler aufgetreten und von onError behandelt wurde

Der Fehler der ratenbegrenzten Funktion, wenn kein onError-Handler konfiguriert ist

const rateLimiter = new AsyncRateLimiter(fn, { limit: 5, window: 1000 });

// First 5 calls will return a promise that resolves with the result
const result = await rateLimiter.maybeExecute('arg1', 'arg2');

// Additional calls within the window will return undefined
const result2 = await rateLimiter.maybeExecute('arg1', 'arg2'); // undefined

const rateLimiter = new AsyncRateLimiter(fn, { limit: 5, window: 1000 });

// First 5 calls will return a promise that resolves with the result
const result = await rateLimiter.maybeExecute('arg1', 'arg2');

// Additional calls within the window will return undefined
const result2 = await rateLimiter.maybeExecute('arg1', 'arg2'); // undefined

reset(): void

reset(): void

Definiert in: async-rate-limiter.ts:468

Setzt den Zustand des Ratenbegrenzers zurück.

void

setOptions(newOptions): void

setOptions(newOptions): void

Definiert in: async-rate-limiter.ts:249

Aktualisiert die Optionen des asynchronen Ratenbegrenzers.

Partial<AsyncRateLimiterOptions<TFn>>

void