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));
request made!
request made!
header: Ana
profile: Ana
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
A received: hi
A received: all good?
B received: all good?
messages$: -a---b--|
A: -a---b--|
B: ---^-b--| ^ = momento do subscribe de B; a = "hi", b = "all good?"
Três coisas para guardar:
- O Subject é hot: o
nextacontece 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
completeouerror, 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
source produced 0
A: 0
B: 0
source produced 1
A: 1
B: 1
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);
A: light
A: dark
B (arrived later): dark
current value: dark
É 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.valueem 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));
just arrived and received: 2nd
just arrived and received: 3rd
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);
request made!
header: Ana
profile: Ana
--- 500 ms later, a third component appears
request made!
footer: Ana
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);
request made!
header: Ana
profile: Ana
--- 500 ms later, a third component appears
footer: Ana
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);
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
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()erefCount(). Todos estão depreciados no RxJS 7, e o guia de migração mostra como trocar porshare,shareReplayeconnectable.
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:
-
Observables que completam sozinhos (um request,
take(1),firstValueFrom) não precisam de unsubscribe manual. -
Guardar a Subscription e chamar
unsubscribe()na hora de destruir. Para várias, junte numa só comsubscription.add(other). -
takeUntil(destroy$): um Subject que emite quando o componente morre. É o mais popular, mas tem uma regra: ele vai por último nopipe.
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);
before switchMap: tick 0
before switchMap: destroyed
before switchMap: tick 1
before switchMap: tick 2
before switchMap: tick 3
last: tick 0
last: destroyed
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-interope o pipeasyncfazem 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");
[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
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çãodispatch. Expor o Subject deixaria qualquer parte do código chamarnext,errorou atécompletee matar o store. Se precisar expor um Subject, devolvasubject.asObservable(), que esconde esses métodos. -
scan(reducer, initial)é o coração: para cada action, calcula o novo state a partir do anterior. OstartWith(initial)garante que quem faz select recebe o state inicial na hora. -
shareReplayfaz duas coisas: uma execução doscanpara 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 orefCount: 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 oscanainda não estaria com subscribe noactions$.
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 nolocalStoragecom umtap, ou um subscribe, emstore.state$.
Resumo
- Observables cold criam uma execução por subscriber; hot compartilham uma execução (multicast).
- Um Subject é observable e observer:
nextentrega para quem está ouvindo agora. -
BehaviorSubjecttem valor atual, e é um bom encaixe para state;ReplaySubject(n)repete os últimosn. -
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 nopipe. - Um store é
Subjectde actions +scancom um reducer puro +shareReplay, eselecté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)