Berhijrah melanggan Panggilan Balik untuk melanggan argumen dalam RxJS

Anda, orang yang menggunakan rxjs dalam kehidupan harian anda, mungkin perasan bahawa sejak versi 6.4. RxJS meletakkan anotasi yang ditamatkan dalam kaedah langgan:

@deprecated — Daripada menghantar argumen panggil balik yang berasingan, gunakan hujah pemerhati. Tandatangan yang mengambil hujah panggil balik yang berasingan akan dialih keluar dalam v8. Butiran: https://rxjs.dev/deprecations/subscribe-arguments

Jusifikasinya ialah menggunakan panggilan balik yang berasingan menjana bacaan kaedah yang lebih teruk, dan oleh itu adalah lebih baik untuk menggunakan argumen langganan, merosakkan sifat yang kaedah itu kembalikan.

Untuk lebih memahami keadaan ini dalam amalan, mari lihat contoh pantas:

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

Ini akan menjadi fail asas kami. Kaedah pertama mengeluarkan nombor dari 1 hingga 5 dalam urutan dengan kaedah .next(); dan sebaik sahaja gelung selesai, yang boleh diperhatikan dilengkapkan dengan kaedah .complete();

Kaedah kedua mencipta pemerhatian yang melemparkan ralat serta-merta

PS: apabila kaedah .error() dipanggil, pemerhatian berhenti memancarkan nilai dan tidak boleh meneruskan pemancaran nilai melalui .next() atau dilengkapkan dengan .complete().

Dan mari kita ke intinya.

Kami akan menggunakan sebagai contoh pertama cara yang tidak digunakan pada masa ini, dan kemudian saya akan menunjukkan cara menggunakan hujah yang boleh diperhatikan.

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

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

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

Perhatikan bahawa kerana ia adalah contoh, ia adalah sesuatu yang lebih kelihatan, tetapi pada masa yang sama, kita perlu mengetahui susunan setiap panggilan balik (seterusnya, ralat dan lengkap).

Yang berkata, mari kita mulakan cara menggunakan hujah yang boleh diperhatikan:

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

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

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

Bermula dari titik ini dengan hujah yang boleh diperhatikan, kami mempunyai bacaan yang lebih bersih tentang perkara yang kami gunakan dalam kaedah langgan, tidak perlu mengisytiharkan panggilan balik atau hujah yang tidak akan kami gunakan.

Ini adalah pemindahan yang mudah dilakukan dan akan meninggalkan kod anda tanpa mesej penamatan untuk API ini.

Atas ialah kandungan terperinci Berhijrah melanggan Panggilan Balik untuk melanggan argumen dalam RxJS. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!