Introdução
Uma Promise entrega um valor e acabou. Mas e os cliques de um botão, as teclas digitadas num campo de busca ou as mensagens de um WebSocket? Isso são vários valores chegando ao longo do tempo. É exatamente esse o problema que os Observables resolvem.
Este é o primeiro de uma série de artigos sobre RxJS, onde vamos aprender os operadores e suas aplicações através de pequenos projetos. Nesta primeira parte, vamos entender o que é um Observable, o conceito base de tudo que a programação reativa com RxJS tem a oferecer, e no final vamos construir um cronômetro.
Os exemplos usam RxJS 7 (7.8.x), a versão estável atual. Todos os trechos de código deste artigo foram executados.
Contexto
Antes de partirmos para as definições em si, vamos entender por que usar observables. Considere o código abaixo:
// Declaramos uma variável e atribuímos o valor 10, portanto x = 10.
let x = 10;
// A mesma coisa com arrays
let array = [1, 2, 3];
Depois de declaradas, essas variáveis podem ser usadas durante todo o programa. A vida seria muito simples se todos os dados se comportassem assim. Mas nem sempre temos os dados de que precisamos no momento em que o programa inicia. Às vezes precisamos fazer uma requisição HTTP que vai trazer esses dados (ou um erro) em algum momento que não sabemos de antemão.
Por exemplo, digamos que precisamos dos dados de um usuário para executar alguma funcionalidade no nosso sistema:
// pegarDadosDoUsuario() faz uma requisição HTTP
const dadosDoUsuario = pegarDadosDoUsuario();
// Função que processa os dados recebidos
facaAlgumaCoisa(dadosDoUsuario);
O problema: facaAlgumaCoisa() roda imediatamente, antes de a resposta chegar. Ela recebe uma Promise pendente (ou undefined) em vez dos dados do usuário, e o resultado é um bug silencioso ou um erro mais adiante. Precisamos que facaAlgumaCoisa() só seja chamada quando os dados existirem.
Promises
Uma Promise representa a promessa de que um valor vai estar disponível em algum momento no futuro. Quando o valor chega, acessamos ele com o método .then():
const requisicao = pegarDadosDoUsuario(); // retorna uma Promise
requisicao.then((dadosDoUsuario) => {
facaAlgumaCoisa(dadosDoUsuario);
});
Enquanto a resposta não chega, o JavaScript não fica parado esperando: o event loop segue executando outras tarefas. Quando a resposta chega, a Promise é resolvida e o callback do .then() é chamado com os dados. Se algo der errado, a Promise é rejeitada e tratamos o erro com .catch().
Duas características das Promises importam para o que vem a seguir:
- Uma Promise entrega um único valor. Depois de resolvida, ela não muda mais.
-
Uma Promise é eager (ansiosa). O código dentro dela começa a rodar no momento em que ela é criada, tenha alguém chamado
.then()ou não.
Observables
Um Observable é como um array, porque representa uma coleção de valores, e é como uma Promise, porque esses valores podem chegar ao longo do tempo. A diferença é que uma Promise entrega um valor, enquanto um Observable pode entregar zero, um ou vários valores, e depois disso pode completar ou terminar com erro.
| Um valor | Vários valores | |
|---|---|---|
| Síncrono (pull) | Função | Iterator/Array |
| Assíncrono (push) | Promise | Observable |
Um detalhe: Observables não são necessariamente assíncronos. Um Observable pode emitir valores de forma síncrona, como você vai ver no exemplo abaixo.
Vamos criar um Observable "na mão" com new Observable() para ver as duas diferenças lado a lado:
import { Observable } from "rxjs";
const promise = new Promise((resolve) => {
console.log("Promise: executor rodou (sem ninguém pedir)");
resolve(1);
resolve(2); // ignorado: uma Promise resolve uma única vez
});
const observable$ = new Observable((subscriber) => {
console.log("Observable: produtor rodou");
subscriber.next(1);
subscriber.next(2);
subscriber.complete();
});
console.log("--- antes do then/subscribe");
promise.then((v) => console.log("Promise entregou", v));
observable$.subscribe((v) => console.log("Observable entregou", v));
console.log("--- depois do then/subscribe");
Saída:
Promise: executor rodou (sem ninguém pedir)
--- antes do then/subscribe
Observable: produtor rodou
Observable entregou 1
Observable entregou 2
--- depois do then/subscribe
Promise entregou 1
Repare em três coisas:
- A Promise rodou assim que foi criada. O Observable só rodou quando chamamos
subscribe(). - O Observable entregou dois valores. A Promise ignorou o segundo
resolve. - O Observable emitiu de forma síncrona (antes do "depois do subscribe"). O
.then()da Promise é sempre assíncrono.
Por convenção, usamos o
$no final do nome de uma variável que guarda um observable:cliques$,tempo$.
Observables são lazy
Observables são preguiçosos, ou lazy. Um observable criado e nunca "assinado" não faz nada: não faz requisição, não registra listener, não liga timer. Ou seja, um observable não curte muito conversar sozinho: se ninguém está ouvindo, ele nem começa a falar!
Quem "ouve" é chamado de subscriber (ou observer): é quem chamou subscribe() no observable. Cada chamada de subscribe() dispara uma nova execução do observable, independente das outras:
import { interval, take } from "rxjs";
const relogio$ = interval(100).pipe(take(3));
relogio$.subscribe((n) => console.log("A recebeu", n));
setTimeout(() => relogio$.subscribe((n) => console.log(" B recebeu", n)), 150);
A recebeu 0
A recebeu 1
B recebeu 0
A recebeu 2
B recebeu 1
B recebeu 2
O B começou depois, mas recebeu a sequência completa desde o 0: cada subscriber ganhou o seu próprio timer. Um observable assim é chamado de cold (frio). O oposto é um observable hot (quente), em que os valores são produzidos independentemente de quem está ouvindo e quem chega atrasado perde o que já passou. Vamos ver os hot (com Subject) numa próxima parte.
O Observer: next, error e complete
O subscribe() recebe um observer: um objeto com até três callbacks.
import { Observable } from "rxjs";
const numeros$ = new Observable((subscriber) => {
subscriber.next(1);
subscriber.next(2);
setTimeout(() => {
subscriber.next(3);
subscriber.complete();
subscriber.next(4); // ignorado: depois de complete, nada mais é entregue
}, 100);
});
console.log("antes do subscribe");
numeros$.subscribe({
next: (valor) => console.log("next:", valor),
error: (erro) => console.error("error:", erro.message),
complete: () => console.log("complete"),
});
console.log("depois do subscribe");
antes do subscribe
next: 1
next: 2
depois do subscribe
next: 3
complete
-
next: chamado para cada valor emitido (zero ou mais vezes). -
error: chamado no máximo uma vez, se o observable falhar. -
complete: chamado no máximo uma vez, quando o observable termina com sucesso.
error e complete são terminais e exclusivos: depois de um deles, nada mais é entregue, nem mesmo o outro.
import { Observable } from "rxjs";
const comErro$ = new Observable((subscriber) => {
subscriber.next("a");
subscriber.error(new Error("falhou"));
subscriber.next("b"); // ignorado
subscriber.complete(); // ignorado
});
comErro$.subscribe({
next: (v) => console.log("next:", v),
error: (e) => console.log("error:", e.message),
complete: () => console.log("complete (nunca aparece)"),
});
// next: a
// error: falhou
Se você só precisa do
next, pode passar uma função direto:obs$.subscribe((v) => ...). Já a forma com várias funções,subscribe(next, error, complete), está depreciada desde o RxJS 6.4. Prefira o objeto{ next, error, complete }.
Unsubscribe e teardown
subscribe() retorna uma Subscription. Chamar unsubscribe() nela encerra a execução, e o observable roda sua lógica de limpeza (o teardown): a função que você retorna de dentro do new Observable().
import { Observable } from "rxjs";
const tique$ = new Observable((subscriber) => {
let n = 0;
const id = setInterval(() => subscriber.next(n++), 100);
// teardown: roda no unsubscribe, no complete ou no error
return () => {
clearInterval(id);
console.log("teardown: setInterval limpo");
};
});
const subscription = tique$.subscribe((n) => console.log("tique", n));
setTimeout(() => subscription.unsubscribe(), 350);
tique 0
tique 1
tique 2
teardown: setInterval limpo
Esse é um dos maiores ganhos dos observables sobre callbacks e Promises: cancelar é parte do contrato. Observable infinito (cliques, timers, WebSocket) sem unsubscribe é vazamento de memória.
Do clique ao Observable com fromEvent
No dia a dia raramente usamos new Observable(). O RxJS traz funções de criação prontas, como fromEvent, que transforma eventos do DOM em um observable. Ele representa todos os cliques que vão acontecer num botão durante a vida da aplicação:
import { fromEvent } from "rxjs";
const botao = document.querySelector("#botao-iniciar");
const cliques$ = fromEvent(botao, "click");
// Até aqui nenhum listener foi registrado: o observable é lazy.
const subscription = cliques$.subscribe((evento) => console.log("O botão foi clicado"));
// Agora sim: um addEventListener foi feito. Cada clique imprime a mensagem.
// O parâmetro `evento` é o MouseEvent, com todas as propriedades do clique.
subscription.unsubscribe(); // remove o listener
E se eu precisar de uma Promise?
Às vezes uma API espera uma Promise (ou você quer usar await). O método toPromise() está depreciado; use firstValueFrom ou lastValueFrom:
import { firstValueFrom, lastValueFrom, interval, take } from "rxjs";
const tres$ = interval(100).pipe(take(3));
console.log("primeiro:", await firstValueFrom(tres$)); // primeiro: 0
console.log("último:", await lastValueFrom(tres$)); // último: 2
Cuidado: lastValueFrom espera o observable completar. Num observable infinito, como cliques, ele nunca resolve.
Diagramas de marble
Trabalhar com observables é trabalhar com streams: valores ordenados no tempo. Como isso pode ser abstrato no começo, usamos diagramas de marble (diagramas de bolinhas) para criar um modelo mental. Neste artigo vamos usar a notação de texto que o próprio RxJS usa nos testes, onde cada - é uma passagem de tempo:
--a---b----c---| valores a, b e c emitidos ao longo do tempo; | = complete
--a---b----# a stream terminou com erro; # = error
--a---b----c----- sem | nem #: uma stream que nunca termina (ex.: cliques)
As letras são os valores. Como na prática trabalhamos com dados complexos, troque as letras pela abstração que quiser: o importante é visualizar os valores sendo emitidos ao longo do tempo.
Os operadores ficam no meio, transformando uma stream em outra. Por exemplo, um map que divide por 10:
interval(100): -0-1-2-3-4-...
map(n => n/10): -0-0.1-0.2-...
Pronto, isso é tudo que você precisa saber sobre diagramas de marble por enquanto. Para brincar com diagramas interativos, veja o RxMarbles.
Criando um cronômetro
Para fixar os conceitos, vamos construir um pequeno cronômetro com dois botões, Iniciar e Parar, e abaixo deles o tempo decorrido em segundos, com uma casa decimal.
Vamos usar TypeScript. A forma mais rápida de ter um projeto rodando é com o Vite:
npm create vite@latest cronometro -- --template vanilla-ts
cd cronometro
npm install rxjs
npm run dev
Se não quiser configurar nada, use o StackBlitz.
O HTML (no index.html):
<!-- Dois botões, um para iniciar e outro para parar.
No h2 mostramos o tempo do cronômetro. -->
<body>
<h1>Cronômetro</h1>
<button id="botao-iniciar">Iniciar</button>
<button id="botao-parar">Parar</button>
<h2 id="tempo">0.0s</h2>
<script type="module" src="/src/cronometro.ts"></script>
</body>
A lógica é simples: teremos 3 observables. Um para os cliques no botão Iniciar, outro para os cliques no botão Parar, e um terceiro que emite a cada 1/10 de segundo para contarmos o tempo decorrido.
Contando o tempo com interval
Para o terceiro, usamos a função de criação interval(), que emite 0, 1, 2, 3... a cada N milissegundos. No RxJS, interval, fromEvent e companhia são funções de criação (criam observables); map, takeUntil e afins são operadores (transformam observables).
import { interval } from "rxjs";
const decimoDeSegundo$ = interval(100);
// imprime 0, 1, 2, 3... a cada 100 milissegundos
decimoDeSegundo$.subscribe((n) => console.log(n));
-0-1-2-3-4-...
Ainda não é o que queremos: recebemos o número de "tiques", e não segundos. Precisamos transformar cada valor, e para isso usamos o operador map. O map do RxJS funciona como o map dos arrays: recebe uma função e devolve os valores transformados. A diferença é que o map do array transforma os itens de um array, e o map do RxJS transforma cada valor emitido pelo observable, conforme ele chega.
Para aplicar operadores, usamos o método pipe(). Ele encadeia operadores e retorna um novo observable; o original não é modificado. Esse é um erro comum:
import { interval, map } from "rxjs";
const decimoDeSegundo$ = interval(100);
decimoDeSegundo$.pipe(map((n) => n / 10)); // errado, resultado descartado: pipe não altera o original
const segundos$ = decimoDeSegundo$.pipe(map((n) => n / 10)); // certo: guarde o novo observable
segundos$.subscribe((s) => console.log(s)); // 0, 0.1, 0.2, 0.3...
Desde o RxJS 7.2, os operadores são importados direto de
"rxjs". O caminho antigo"rxjs/operators"está depreciado.
Observando os botões
Agora pegamos a referência dos botões e criamos um observable para os cliques de cada um com fromEvent:
import { fromEvent } from "rxjs";
const botaoIniciar = document.querySelector<HTMLButtonElement>("#botao-iniciar")!;
const botaoParar = document.querySelector<HTMLButtonElement>("#botao-parar")!;
const cliqueIniciar$ = fromEvent(botaoIniciar, "click");
const cliqueParar$ = fromEvent(botaoParar, "click");
Como exercício, faça o subscribe nos cliques, coloque um console.log em cada um e veja se está tudo funcionando. Para cada clique, um log deve aparecer!
Juntando tudo
import { fromEvent, interval, map, switchMap, takeUntil } from "rxjs";
const botaoIniciar = document.querySelector<HTMLButtonElement>("#botao-iniciar")!;
const botaoParar = document.querySelector<HTMLButtonElement>("#botao-parar")!;
const tempo = document.querySelector<HTMLElement>("#tempo")!;
const cliqueIniciar$ = fromEvent(botaoIniciar, "click");
const cliqueParar$ = fromEvent(botaoParar, "click");
const decimoDeSegundo$ = interval(100);
const tempoDecorrido$ = cliqueIniciar$.pipe(
switchMap(() =>
decimoDeSegundo$.pipe(
map((n) => (n + 1) / 10), // interval começa em 0 após 100 ms
takeUntil(cliqueParar$)
)
)
);
tempoDecorrido$.subscribe((segundos) => {
tempo.textContent = `${segundos.toFixed(1)}s`;
});
Ok, algumas coisas estão acontecendo aqui, vamos por partes.
switchMap: a cada clique em Iniciar, queremos começar uma contagem nova. O switchMap faz exatamente isso: para cada valor de cliqueIniciar$, ele faz o subscribe num observable interno (a nossa contagem). Se Iniciar for clicado de novo, ele faz o unsubscribe da contagem anterior antes de começar a próxima. Sem ele, cada clique extra em Iniciar criaria mais um timer em paralelo, todos escrevendo no mesmo <h2>. O switchMap merece um artigo próprio; por enquanto, pense nele como "troque para este novo observable".
map((n) => (n + 1) / 10): o interval emite 0 só depois dos primeiros 100 ms, então somamos 1 para que o display mostre o tempo realmente decorrido. O toFixed(1) garante o formato 1.0s em vez de 1s.
takeUntil(cliqueParar$): deixa os valores passarem até o observable passado como parâmetro emitir. Quando Parar é clicado, o takeUntil completa a stream e faz o unsubscribe do interval automaticamente. E como ele sabe que Parar foi clicado se ninguém fez subscribe em cliqueParar$? O próprio takeUntil faz o subscribe (e depois o unsubscribe) no observable que recebe.
Em diagrama de marble:
cliqueIniciar$: --i----------------i-------------
cliqueParar$: --------------p----------------p-
tempoDecorrido$: ---1-2-3-4-5-------1-2-3-4-5-6---
(1 = 0.1s, 2 = 0.2s...; depois do Parar o display congela no último valor)
Repare também que o único subscribe está no final. Em RxJS, prefira compor observables com operadores a fazer um subscribe dentro de outro subscribe: assim cancelamento e limpeza ficam por conta da biblioteca.
Nota de precisão: contar tiques de
intervalé ótimo para aprender, mas timers do navegador podem atrasar (e abas em segundo plano são limitadas). Num cronômetro de verdade, guardeperformance.now()no início e calcule a diferença a cada tique.
E assim finalizamos o nosso cronômetro! Na próxima parte vamos mergulhar nos operadores. Qualquer crítica construtiva é bem-vinda nos comentários.
Resumo
- Um Observable entrega zero, um ou vários valores ao longo do tempo, e termina com
completeouerror(ou nunca termina). - Observables são lazy: nada acontece até alguém chamar
subscribe(), e cada subscribe é uma execução nova (cold). - O observer é um objeto
{ next, error, complete };errorecompletesão terminais. -
subscribe()retorna uma Subscription;unsubscribe()cancela e roda o teardown. -
pipe()retorna um novo observable; operadores não modificam o original. - Para converter em Promise, use
firstValueFrom/lastValueFrom.
Links para leitura:
Top comments (0)