Migrieren von Abonnementrückrufen zu Abonnementargumenten in RxJS

Sie, die Person, die rxjs in Ihrem täglichen Leben verwendet, haben das möglicherweise seit Version 6.4 bemerkt. RxJS hat eine veraltete Anmerkung in die Methode subscribe:

eingefügt

@deprecated – Anstatt separate Rückrufargumente zu übergeben, verwenden Sie ein Beobachterargument. Signaturen, die separate Rückrufargumente annehmen, werden in Version 8 entfernt. Details: https://rxjs.dev/deprecations/subscribe-arguments

Die Begründung besteht darin, dass die Verwendung separater Rückrufe zu einer schlechteren Lesbarkeit der Methode führt und es daher vorzuziehen ist, Subscribe-Argumente zu verwenden, die die Eigenschaften zerstören, die die Methode zurückgibt.

Um besser zu verstehen, wie das in der Praxis aussieht, schauen wir uns ein kurzes Beispiel an:

data.js

import { Observable } from "rxjs";

/**
 * Cria um observable que emite valores numéricos de 1 até 5, e então se finaliza.
 *
 * @returns {Observable<number>} Um observable que emite números de 1 até 5 em sequência.
 */
export const data = () => {
  return new Observable((observer) => {
    for (let i = 1; i <= 5; i++) {
      observer.next(i);
    }

    observer.complete();
  });
};

/**
 * Cria um observable que emite um error imediatamente
 *
 * @returns {Observable<never>} Um observable que emite um erro.
 */
export const dataWithError = () => {
  return new Observable((observer) => {
    observer.error("Aconteceu um erro!");
  });
};

Dies wird unsere Basisdatei sein. Die erste Methode gibt Zahlen von 1 bis 5 der Reihe nach mit der Methode .next(); aus, und sobald die Schleife beendet ist, wird das Observable mit der Methode .complete(); vervollständigt

Die zweite Methode erstellt ein Observable, das sofort einen Fehler auslöst

PS: Wenn die Methode .error() aufgerufen wird, stoppt das Observable die Ausgabe von Werten und kann nicht weiterhin Werte über .next() ausgeben oder mit .complete() vervollständigt werden.

Und kommen wir zum Punkt.

Wir werden als erstes Beispiel die Art und Weise verwenden, die derzeit veraltet ist, und dann werde ich zeigen, wie man das beobachtbare Argument verwendet.

import { data, dataWithError } from "./data.js";

data().subscribe(
  (value) => console.log(value),
  (error) => {},
  () => {
    console.log("completou");
  }
);

dataWithError().subscribe(
  () => {},
  (error) => {
    console.error({ error });
  }
);

Beachten Sie, dass es sich um etwas Sichtbareres handelt, da es sich um ein Beispiel handelt. Gleichzeitig müssen wir jedoch die Reihenfolge jedes Rückrufs kennen (nächster, Fehler und abgeschlossener Rückruf).

Aber jetzt kommen wir zur Verwendung von Argumentobservablen:

import { data, dataWithError } from "./data.js";

data().subscribe({
  next: (data) => console.log(data),
  complete: () => console.log("completou"),
});

dataWithError()
    .subscribe({ error: (error) => console.error({ error })
    });

Von diesem Punkt an haben wir mit dem Argument Observables eine klarere Vorstellung davon, was wir innerhalb der subscribe-Methode verwenden, und müssen keine Rückrufe oder Argumente deklarieren, die wir nicht verwenden werden.

Die Migration ist einfach durchzuführen und hinterlässt Ihren Code ohne veraltete Meldungen für diese API.

Das obige ist der detaillierte Inhalt vonMigrieren von Abonnementrückrufen zu Abonnementargumenten in RxJS. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!