DEV Community

Edward Teixeira Dias Junior
Edward Teixeira Dias Junior

Posted on

RxJS parte 4: Subjects, hot vs cold e um mini store

Introdução

Na parte 1 a gente viu que observables são cold: cada subscribe dispara uma execução nova. No fim da parte 3 ficou um problema no ar: se dois pedaços da tela fizerem subscribe na mesma busca, são dois requests por termo. Neste artigo a gente vai entender o porquê, conhecer os Subjects, compartilhar uma execução entre vários subscribers com share e shareReplay, ver como evitar memory leak, e no final montar um mini store de carrinho de compras, a mesma ideia por trás de bibliotecas como NgRx, com poucas dezenas de linhas.

Os exemplos usam RxJS 7 (7.8.x). Todos os trechos de código deste artigo foram executados, e as saídas mostradas são as saídas reais.

O problema do observable cold

Um observable cold é como um vídeo sob demanda: cada pessoa que dá play assiste do começo, na sua própria sessão. Para um interval, tudo bem, e para um HTTP request, nem tanto:

import { Observable } from "rxjs";

const user$ = new Observable((subscriber) => {
  console.log("request made!");
  setTimeout(() => {
    subscriber.next({ name: "Ana" });
    subscriber.complete();
  }, 100);
});

user$.subscribe((u) => console.log("header:", u.name));
user$.subscribe((u) => console.log("profile:", u.name));
Enter fullscreen mode Exit fullscreen mode
request made!
request made!
header: Ana
profile: Ana
Enter fullscreen mode Exit fullscreen mode

Dois subscribers, dois requests. O que a gente quer é uma transmissão ao vivo: uma execução só, e todo mundo que estiver ouvindo recebe os mesmos valores. Isso é um observable hot, e o nome técnico para "uma execução, vários ouvintes" é multicast.

Subject: observable e observer ao mesmo tempo

Um Subject é um tipo especial de observable que guarda uma lista de subscribers. E ele também é um observer: tem next, error e complete. Quando a gente chama subject.next(value), todos os subscribers daquele momento recebem o valor:

import { Subject } from "rxjs";

const messages$ = new Subject();

messages$.subscribe((m) => console.log("A received:", m));
messages$.next("hi");

messages$.subscribe((m) => console.log("  B received:", m));
messages$.next("all good?");

messages$.complete();
messages$.next("anyone there?"); // ignored: the subject completed
Enter fullscreen mode Exit fullscreen mode
A received: hi
A received: all good?
  B received: all good?
Enter fullscreen mode Exit fullscreen mode
messages$:   -a---b--|
A:           -a---b--|
B:           ---^-b--|      ^ = momento do subscribe de B; a = "hi", b = "all good?"
Enter fullscreen mode Exit fullscreen mode

Três coisas para guardar:

  • O Subject é hot: o next acontece independentemente de quem está ouvindo. O B chegou atrasado e perdeu o "hi", e ninguém volta a fita para ele.
  • No Subject, diferente de um observable cold, quem produz os valores está fora dele: é quem chama next.
  • Ele segue o mesmo contrato da parte 1: depois de complete ou error, acabou.

Como o Subject é um observer, dá para passá-lo direto para o subscribe de outro observable. Assim uma execução da source é repassada para todos os subscribers do Subject:

import { Subject, interval, take, tap } from "rxjs";

const bridge$ = new Subject();

bridge$.subscribe((n) => console.log("A:", n));
bridge$.subscribe((n) => console.log("  B:", n));

interval(100)
  .pipe(
    take(2),
    tap((n) => console.log("source produced", n))
  )
  .subscribe(bridge$); // the Subject is the observer
Enter fullscreen mode Exit fullscreen mode
source produced 0
A: 0
  B: 0
source produced 1
A: 1
  B: 1
Enter fullscreen mode Exit fullscreen mode

Uma execução do interval, dois ouvintes, e isso é multicast feito na mão. Mais abaixo a gente vai ver operators que fazem isso por nós.

BehaviorSubject: sempre tem um valor atual

O BehaviorSubject é um Subject com memória do último valor. Ele nasce com um valor inicial, e quem faz subscribe recebe na hora o valor atual, mesmo chegando atrasado:

import { BehaviorSubject } from "rxjs";

const theme$ = new BehaviorSubject("light");

theme$.subscribe((t) => console.log("A:", t));
theme$.next("dark");
theme$.subscribe((t) => console.log("  B (arrived later):", t));

console.log("current value:", theme$.value);
Enter fullscreen mode Exit fullscreen mode
A: light
A: dark
  B (arrived later): dark
current value: dark
Enter fullscreen mode Exit fullscreen mode

É o tipo de Subject ideal para state: tema da aplicação, usuário logado, filtros de uma tela. Sempre existe um valor "atual", e quem chega precisa dele imediatamente.

O .value é prático, mas use com moderação. Se a gente se pegar lendo .value em todo lugar, está voltando para o mundo imperativo e perdendo o "me avise quando mudar".

ReplaySubject: guarda os últimos N

O ReplaySubject(n) guarda os últimos n valores e os repete para cada novo subscriber:

import { ReplaySubject } from "rxjs";

const latestNotifications$ = new ReplaySubject(2);

latestNotifications$.next("1st");
latestNotifications$.next("2nd");
latestNotifications$.next("3rd");

latestNotifications$.subscribe((n) => console.log("just arrived and received:", n));
Enter fullscreen mode Exit fullscreen mode
just arrived and received: 2nd
just arrived and received: 3rd
Enter fullscreen mode Exit fullscreen mode

Diferente do BehaviorSubject, ele não precisa de valor inicial, e se nada foi emitido, o novo subscriber não recebe nada, e também não tem .value. Existe ainda o AsyncSubject, que só entrega o último valor e só quando completa, mas ele é bem menos comum.

Tipo Quem chega atrasado recebe...
Subject nada do que já passou
BehaviorSubject o valor atual (há sempre um)
ReplaySubject(n) os últimos n valores
AsyncSubject o último valor, só após o complete

share: multicast sem criar Subject na mão

Fazer source.subscribe(subject) na mão funciona, mas aí a gente precisa decidir quando ligar, quando desligar e o que fazer com quem chega depois. O operator share() faz isso por nós: ele cria um Subject por baixo dos panos, liga a source quando chega o primeiro subscriber e a desliga quando o último sai, e isso se chama reference counting.

Voltando ao exemplo do usuário:

import { Observable, share } from "rxjs";

const user$ = new Observable((subscriber) => {
  console.log("request made!");
  setTimeout(() => {
    subscriber.next({ name: "Ana" });
    subscriber.complete();
  }, 100);
}).pipe(share());

user$.subscribe((u) => console.log("header:", u.name));
user$.subscribe((u) => console.log("profile:", u.name));

setTimeout(() => {
  console.log("--- 500 ms later, a third component appears");
  user$.subscribe((u) => console.log("footer:", u.name));
}, 500);
Enter fullscreen mode Exit fullscreen mode
request made!
header: Ana
profile: Ana
--- 500 ms later, a third component appears
request made!
footer: Ana
Enter fullscreen mode Exit fullscreen mode

Os dois primeiros compartilharam um request. Mas o rodapé, que chegou depois de o request completar, disparou outro. Nesse exemplo, duas coisas podem acontecer: quem chega junto compartilha a execução, e/ou quem chega depois da source completar dispara uma execução nova, porque por padrão o share "reseta". Para dados que a gente quer guardar e entregar para quem chegar depois, existe o shareReplay.

shareReplay: compartilhar e lembrar

O shareReplay é um share que usa um ReplaySubject por baixo. Quem chega depois recebe os últimos valores guardados, sem nova execução:

import { Observable, shareReplay } from "rxjs";

const user$ = new Observable((subscriber) => {
  console.log("request made!");
  setTimeout(() => {
    subscriber.next({ name: "Ana" });
    subscriber.complete();
  }, 100);
}).pipe(shareReplay({ bufferSize: 1, refCount: true }));

user$.subscribe((u) => console.log("header:", u.name));
user$.subscribe((u) => console.log("profile:", u.name));

setTimeout(() => {
  console.log("--- 500 ms later, a third component appears");
  user$.subscribe((u) => console.log("footer:", u.name));
}, 500);
Enter fullscreen mode Exit fullscreen mode
request made!
header: Ana
profile: Ana
--- 500 ms later, a third component appears
footer: Ana
Enter fullscreen mode Exit fullscreen mode

Um request só, e o rodapé recebeu o valor guardado. É o padrão clássico de cache de um request.

O problema do refCount

Repare que a gente passou refCount: true, e isso importa. Segundo a documentação, por padrão o shareReplay usa refCount: false: mesmo quando todos os subscribers saem, ele continua com a subscription na source. Para um request que completa, tanto faz, e para uma source longa é um memory leak:

import { interval, take, tap, shareReplay } from "rxjs";

const source = (name) => interval(100).pipe(take(4), tap((n) => console.log(`${name}: source produced ${n}`)));

// refCount false (the default): the source keeps going after everyone leaves
source("without refCount").pipe(shareReplay(1), take(1)).subscribe((n) => console.log("received", n));

setTimeout(() => {
  // refCount true: the last subscriber left, the source is shut down
  source("with refCount").pipe(shareReplay({ bufferSize: 1, refCount: true }), take(1)).subscribe((n) => console.log("received", n));
}, 600);
Enter fullscreen mode Exit fullscreen mode
without refCount: source produced 0
received 0
without refCount: source produced 1
without refCount: source produced 2
without refCount: source produced 3
with refCount: source produced 0
received 0
Enter fullscreen mode Exit fullscreen mode

Os dois só queriam o primeiro valor (take(1)). Sem refCount, a source continuou rodando para ninguém. Aqui ela parou sozinha por causa do take(4), mas imagine um interval sem fim ou um WebSocket. Regra prática: use shareReplay({ bufferSize: 1, refCount: true }), a não ser que a gente queira de propósito manter a source ligada.

Em código antigo você vai encontrar publish(), multicast(), publishReplay() e refCount(). Todos estão depreciados no RxJS 7, e o guia de migração mostra como trocar por share, shareReplay e connectable.

Memory leaks e como fazer unsubscribe

Na parte 1 a gente viu: observable infinito sem unsubscribe é memory leak. Cada subscribe esquecido num fromEvent, interval ou Subject mantém vivos os callbacks e tudo que eles referenciam. Num SPA, em que componentes nascem e morrem o tempo todo, isso se acumula.

Os padrões mais usados:

  1. Observables que completam sozinhos (um request, take(1), firstValueFrom) não precisam de unsubscribe manual.
  2. Guardar a Subscription e chamar unsubscribe() na hora de destruir. Para várias, junte numa só com subscription.add(other).
  3. takeUntil(destroy$): um Subject que emite quando o componente morre. É o mais popular, mas tem uma regra: ele vai por último no pipe.

Por que por último? Veja o que acontece com um takeUntil antes de um switchMap:

import { Subject, interval, take, switchMap, takeUntil } from "rxjs";

function component(name, takeUntilLast) {
  const clicks$ = new Subject();
  const destroy$ = new Subject();
  const ticks = (c) => interval(100).pipe(take(4));

  const stream$ = takeUntilLast
    ? clicks$.pipe(switchMap(ticks), takeUntil(destroy$))
    : clicks$.pipe(takeUntil(destroy$), switchMap(ticks));

  stream$.subscribe((n) => console.log(`${name}: tick ${n}`));
  clicks$.next("click");
  setTimeout(() => {
    console.log(`${name}: destroyed`);
    destroy$.next();
    destroy$.complete();
  }, 150);
}

component("before switchMap", false);
setTimeout(() => component("last", true), 600);
Enter fullscreen mode Exit fullscreen mode
before switchMap: tick 0
before switchMap: destroyed
before switchMap: tick 1
before switchMap: tick 2
before switchMap: tick 3
last: tick 0
last: destroyed
Enter fullscreen mode Exit fullscreen mode

Nesse exemplo, duas coisas podem acontecer. Com o takeUntil antes do switchMap, ele só corta os cliques, e o inner que já estava rodando continua vivo depois do "destroyed", porque nada mandou ele parar. Com o takeUntil por último, ele corta o stream inteiro, inner incluído.

Se você usa Angular, o takeUntilDestroyed() do @angular/core/rxjs-interop e o pipe async fazem esse trabalho por você.

Projeto: um mini store de carrinho

Vamos juntar o que vimos e construir um store, um lugar único que guarda o state de um carrinho de compras e avisa quem estiver interessado quando ele muda. A ideia é a mesma de bibliotecas como NgRx e Redux:

  • A tela não altera o state direto. Ela despacha actions ({ type: "add", ... }).
  • Uma função pura, o reducer, calcula o novo state a partir do state atual e da action.
  • Quem quer ler, faz select de uma fatia do state e recebe atualizações só quando aquela fatia muda.

O scan da parte 2, "acumular um valor a cada evento", é exatamente um reducer de state. O src/cart.ts:

import { Subject, type Subscription, scan, startWith, shareReplay, map, distinctUntilChanged, takeUntil, type Observable } from "rxjs";

// ---------- the generic store ----------
function createStore<S, A>(reducer: (state: S, action: A) => S, initial: S) {
  const actions$ = new Subject<A>();
  const state$ = actions$.pipe(
    scan(reducer, initial),
    startWith(initial),
    shareReplay({ bufferSize: 1, refCount: false }) // on purpose: the store lives as long as the app does
  );
  const connection: Subscription = state$.subscribe(); // subscribe now: actions dispatched before anyone listens are not lost

  function select<R>(selector: (state: S) => R): Observable<R> {
    return state$.pipe(map(selector), distinctUntilChanged());
  }

  return {
    state$, // read-only: nobody outside calls next
    dispatch: (action: A) => actions$.next(action),
    select,
    destroy: () => connection.unsubscribe(),
  };
}

// ---------- the domain: cart ----------
interface Item { id: string; name: string; price: number; qty: number }
interface Cart { items: Item[] }
type Action =
  | { type: "add"; product: Omit<Item, "qty"> }
  | { type: "remove"; id: string }
  | { type: "clear" };

let reducerRuns = 0;
function reducer(state: Cart, action: Action): Cart {
  reducerRuns++;
  switch (action.type) {
    case "add": {
      const exists = state.items.some((i) => i.id === action.product.id);
      return {
        items: exists
          ? state.items.map((i) => (i.id === action.product.id ? { ...i, qty: i.qty + 1 } : i))
          : [...state.items, { ...action.product, qty: 1 }],
      };
    }
    case "remove":
      return { items: state.items.filter((i) => i.id !== action.id) };
    case "clear":
      return { items: [] };
  }
}

const store = createStore(reducer, { items: [] });

// ---------- selectors ----------
const quantity$ = store.select((c) => c.items.reduce((sum, i) => sum + i.qty, 0));
const summary$ = store.select((c) => {
  const names = c.items.map((i) => `${i.qty}x ${i.name}`).join(", ") || "empty";
  const total = c.items.reduce((sum, i) => sum + i.price * i.qty, 0);
  return `${names} | R$ ${total.toFixed(2)}`;
});

// ---------- "components" ----------
const destroyBadge$ = new Subject<void>();
quantity$.pipe(takeUntil(destroyBadge$)).subscribe((q) => console.log(`[badge] ${q} item(s)`));

summary$.subscribe((r) => console.log(`[summary] ${r}`));

// ---------- using it ----------
const coffee = { id: "coffee", name: "Coffee", price: 18.9 };
const bread = { id: "cheese-bread", name: "Cheese bread", price: 12.5 };

store.dispatch({ type: "add", product: coffee });
store.dispatch({ type: "add", product: bread });
store.dispatch({ type: "add", product: coffee });

console.log("--- the badge leaves the screen");
destroyBadge$.next();
destroyBadge$.complete();

store.dispatch({ type: "remove", id: "cheese-bread" });
store.dispatch({ type: "clear" });
store.dispatch({ type: "clear" }); // the cart was already empty
console.log("reducer ran", reducerRuns, "times");
Enter fullscreen mode Exit fullscreen mode
[badge] 0 item(s)
[summary] empty | R$ 0.00
[badge] 1 item(s)
[summary] 1x Coffee | R$ 18.90
[badge] 2 item(s)
[summary] 1x Coffee, 1x Cheese bread | R$ 31.40
[badge] 3 item(s)
[summary] 2x Coffee, 1x Cheese bread | R$ 50.30
--- the badge leaves the screen
[summary] 2x Coffee | R$ 37.80
[summary] empty | R$ 0.00
reducer ran 6 times
Enter fullscreen mode Exit fullscreen mode

O createStore é genérico e não sabe nada de carrinho, e vale olhar cada pedaço.

  • actions$ é um Subject: a porta de entrada das actions. Ele fica privado dentro da função, e para fora só sai a função dispatch. Expor o Subject deixaria qualquer parte do código chamar next, error ou até complete e matar o store. Se precisar expor um Subject, devolva subject.asObservable(), que esconde esses métodos.
  • scan(reducer, initial) é o coração: para cada action, calcula o novo state a partir do anterior. O startWith(initial) garante que quem faz select recebe o state inicial na hora.
  • shareReplay faz duas coisas: uma execução do scan para todos os selectors (o reducer rodou 6 vezes para 6 actions, e não 6 × o número de selectors), e quem chega depois recebe o state atual. Aqui o refCount: false é de propósito: o state não pode ser jogado fora só porque nenhum componente está olhando naquele instante.
  • state$.subscribe() liga o store na criação. Lembra que o Subject é hot? Sem essa linha, uma action despachada antes do primeiro select cairia no vazio, porque o scan ainda não estaria com subscribe no actions$.

select é map + distinctUntilChanged (parte 2). Repare no último clear: o reducer rodou, mas o summary continuou "empty | R$ 0.00", e o distinctUntilChanged não deixou o componente acordar à toa. Cada componente só acorda quando a sua fatia muda.

Um selector summary$ em vez de dois: daria para ter um selector para os nomes, outro para o total, e juntar com combineLatest([names$, total$]). Mas como os dois mudam com a mesma action, ele emitiria duas vezes por action, a primeira com um valor novo e outro velho, por exemplo, "1x Coffee | R$ 0.00". Quando os dados vêm do mesmo state, derive tudo num selector só.

O badge com takeUntil(destroyBadge$): o padrão da seção anterior. Depois do "the badge leaves the screen", ele não recebe mais nada.

O reducer é uma função pura: recebe state e action e devolve um state novo, sem alterar o anterior, por isso os spreads. Os nossos selectors devolvem strings e números, que o === compara por valor. Se um selector devolver um objeto ou array, o distinctUntilChanged só ajuda se o reducer preservar as referências do que não mudou.

Para ligar isso na tela, os "componentes" seriam subscribes que atualizam o DOM em vez de dar console.log, e os botões chamariam store.dispatch(...), por exemplo, dentro de um fromEvent(button, "click"). No Angular, é o tipo de coisa que a gente ligaria com o pipe async.

Exercício: adicione uma action { type: "decrement"; id: string } que tira uma unidade e remove o item quando chegar a zero. E depois tente persistir o carrinho no localStorage com um tap, ou um subscribe, em store.state$.

Resumo

  • Observables cold criam uma execução por subscriber; hot compartilham uma execução (multicast).
  • Um Subject é observable e observer: next entrega para quem está ouvindo agora.
  • BehaviorSubject tem valor atual, e é um bom encaixe para state; ReplaySubject(n) repete os últimos n.
  • share() compartilha enquanto houver subscribers; shareReplay({ bufferSize: 1, refCount: true }) também guarda o último valor para quem chega depois.
  • O padrão do shareReplay é refCount: false: a source continua ligada sem ninguém ouvindo.
  • Para evitar memory leak: deixe completar, guarde a Subscription ou use takeUntil(destroy$) por último no pipe.
  • Um store é Subject de actions + scan com um reducer puro + shareReplay, e select é map + distinctUntilChanged.

A série fecha aqui: a gente saiu de "o que é um Observable" para um cronômetro, uma busca com HTTP de verdade e um store. Se quiser continuar, os próximos assuntos naturais são os operators de combinação (combineLatest, withLatestFrom, merge) e os testes com diagramas de marble, que usam a mesma notação de texto que usamos aqui.

Links para leitura:

Top comments (0)