Migration des rappels d'abonnement pour abonner les arguments dans RxJS

Vous, la personne qui utilisez rxjs dans votre vie quotidienne, avez peut-être remarqué cela depuis la version 6.4. RxJS a placé une annotation obsolète dans la méthode Subscribe:

@deprecated — Au lieu de transmettre des arguments de rappel séparés, utilisez un argument d'observateur. Les signatures prenant des arguments de rappel distincts seront supprimées dans la v8. Détails : https://rxjs.dev/deprecations/subscribe-arguments

La justification est que l'utilisation de rappels séparés génère une moins bonne lecture de la méthode, et il est donc préférable d'utiliser des arguments d'abonnement, déstructurant les propriétés renvoyées par la méthode.

Pour mieux comprendre à quoi cela ressemble en pratique, regardons un exemple rapide :

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!");
  });
};

Ce sera notre fichier de base. La première méthode génère des nombres de 1 à 5 en séquence avec la méthode .next(); et dès que la boucle est terminée, l'observable est complété avec la méthode .complete();

La deuxième méthode crée un observable qui renvoie immédiatement une erreur

PS : lorsque la méthode .error() est appelée, l'observable cesse d'émettre des valeurs et ne peut pas continuer à émettre des valeurs via .next() ou se compléter avec .complete().

Et allons droit au but.

Nous utiliserons comme premier exemple la méthode actuellement obsolète, puis je montrerai comment utiliser l'argument observable.

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

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

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

Notez que parce qu'il s'agit d'un exemple, c'est quelque chose de plus visible, mais en même temps, nous devons connaître l'ordre de chaque rappel (suivant, erreur et complet).

Cela dit, voyons comment utiliser les arguments observables :

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

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

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

À partir de maintenant, avec les arguments observables, nous avons une lecture plus claire de ce que nous utilisons dans la méthode d'abonnement, sans avoir besoin de déclarer des rappels ou des arguments que nous n'utiliserons pas.

Il s'agit d'une migration facile à effectuer et laissera votre code sans messages de dépréciation pour cette API.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!