5. Observables e estado compartilhado
5.1. Exemplo 19: observables RxJS
Já encontramos dois tipos de valores que mudam ao longo do tempo: os signals, que sempre têm um valor atual, e as promises, que entregam um único valor mais tarde. O [Angular] usa um terceiro tipo: os observables, fornecidos pela biblioteca [RxJS]. Um observable é um fluxo de valores que chegam ao longo do tempo: teclas digitadas, ticks de um temporizador, eventos do roteador (Exemplo 17), a resposta de um servidor (Exemplo 22).
Seu poder está nos operadores: funções que transformam um fluxo em outro (filtrar, esperar, descartar uma requisição expirada etc.). Este exemplo apresenta os principais em três cenários.
| // =========================================================================
// 19-rxjs/src/app/app.ts - os observables da biblioteca RxJS
// -------------------------------------------------------------------------
// Um OBSERVABLE é um FLUXO de valores, que chegam ao longo do tempo (as
// teclas digitadas, os ticks de um timer, a resposta de um servidor...).
// O Angular os usa bastante: o cliente HTTP (exemplo 22) e o roteador
// (exemplo 17) retornam observables.
// - observable.subscribe(function): nos INSCREVEMOS; a função recebe
// cada valor. Nada acontece enquanto ninguém estiver inscrito;
// - observable.pipe(op1, op2...): um NOVO fluxo, transformado por
// OPERADORES (map, filter, debounceTime, switchMap...);
// - toSignal(observable): um signal cujo valor é o último valor recebido
// (inscrição e cancelamento automáticos).
// =========================================================================
import { Component, DestroyRef, inject, signal } from '@angular/core';
import { takeUntilDestroyed, toSignal } from '@angular/core/rxjs-interop';
import { debounceTime, delay, distinctUntilChanged, filter, interval, map, Observable, of, Subject, switchMap, take, tap } from 'rxjs';
const DOCTORS = ['Marie PELISSIER', 'Paul TATOU', 'Sophie DUPONT', 'Jacques DURAND', 'Martine PELLETIER'];
@Component({
selector: 'app-root',
templateUrl: './app.html',
})
export class App {
protected readonly log = signal<string[]>([]);
// 2. um timer: 0, 1, 2... a cada segundo; take(20): 20 valores
// e então o fluxo é concluído; map: cada valor é transformado
private readonly seconds$ = interval(1000).pipe(
take(20),
map((n) => 20 - n - 1),
);
// toSignal: a contagem regressiva, como um signal
protected readonly countdown = toSignal(this.seconds$, { initialValue: 20 });
// 3. uma busca "enquanto você digita": um Subject é um observable
// no qual nós mesmos EMPURRAMOS valores (next)
private readonly inputs = new Subject<string>();
protected readonly results = toSignal(
this.inputs.pipe(
map((text) => text.trim().toLowerCase()),
debounceTime(400), // esperamos 400 ms sem nenhuma tecla digitada
distinctUntilChanged(), // ignoramos um texto idêntico ao anterior
filter((text) => text.length >= 2),
tap((text) => this.trace(`search sent: "${text}"`)),
// switchMap: uma busca por texto; se um novo texto chegar
// antes da resposta, a busca antiga é ABANDONADA
switchMap((text) => this.search(text)),
),
{ initialValue: [] as string[] },
);
constructor() {
// 1. um observable construído à mão: emite três valores e depois é concluído
const threeValues = new Observable<string>((subscriber) => {
subscriber.next('one');
subscriber.next('two');
setTimeout(() => {
subscriber.next('three (one second later)');
subscriber.complete();
}, 1000);
});
// takeUntilDestroyed: a inscrição termina se o componente desaparecer
threeValues.pipe(takeUntilDestroyed(inject(DestroyRef))).subscribe({
next: (value) => this.trace(`received: ${value}`),
complete: () => this.trace('stream completed'),
});
}
protected onInput(text: string): void {
this.inputs.next(text);
}
// um "servidor" simulado: a resposta chega após um atraso aleatório
private search(text: string): Observable<string[]> {
const found = DOCTORS.filter((m) => m.toLowerCase().includes(text));
return of(found).pipe(delay(200 + Math.random() * 600));
}
private trace(message: string): void {
this.log.update((j) => [...j, `${new Date().toLocaleTimeString()} ${message}`]);
}
}
|
- linha 18: as funções e os operadores usados são todos importados de [rxjs];
Um observable construído manualmente:
- linhas 57–64: um observable é construído a partir de uma função, que é chamada para cada assinante. Ele emite valores com [next] (linhas 58, 59, 61) e depois sinaliza o fim do fluxo com [complete] (linha 62);
- linha 66: [subscribe]: o código se inscreve no fluxo. Nada acontece até que alguém se inscreva: a função das linhas 57–64 só é executada nesse momento. O objeto passado a [subscribe] especifica o que fazer com cada valor (linha 67) e com o fim do fluxo (linha 68);
- linha 66: [pipe] encadeia operadores. [takeUntilDestroyed] interrompe a inscrição se o componente desaparecer: uma inscrição esquecida continuaria ativa para um componente que não existe mais.
Uma contagem regressiva:
- Linha 31: [interval(1000)] emite 0, 1, 2... a cada segundo, indefinidamente;
- Linha 32: [take(20)] mantém apenas os vinte primeiros valores e depois encerra o fluxo;
- linha 33: [map] transforma cada valor: 0, 1, 2... viram 19, 18, 17...;
- linha 36: [toSignal] converte o fluxo em um signal, que recebe o último valor recebido e que o template lê como qualquer outro signal. [toSignal] se inscreve no fluxo e cancela a inscrição quando o componente desaparece. [initialValue]: o valor do signal antes do primeiro valor do fluxo.
Por convenção, o nome de uma variável que contém um observable termina com [$] (linha 31).
Uma busca enquanto se digita:
Este é um exemplo clássico de observables: queremos buscar médicos cujo nome contenha o texto digitado, sem enviar uma requisição ao servidor a cada tecla e sem arriscar que uma resposta lenta sobrescreva uma mais recente.
- Linha 40: um
***[Subject] é um observable no qual nós mesmos *inserimos valores, com ***[next]***: linha 73, a cada tecla digitada (o template chama [onInput] a cada evento [input]);
- linha 43: o texto é limpo (sem espaços nas extremidades, em minúsculas);
- linha 44: [debounceTime(400)] só emite um valor se nenhum outro chegar em 400 ms: enquanto o usuário digita, nada é enviado;
- linha 45: [distinctUntilChanged] ignora um valor idêntico ao anterior (“pel” e, em seguida, “pelx” imediatamente apagado: “pel” novamente);
- linha 46: [filter] mantém apenas textos com pelo menos duas letras;
- linha 47: [tap] executa uma ação sem modificar o fluxo: neste caso, uma linha no log;
- linha 50: [switchMap] substitui cada texto pelo resultado de sua busca (linhas 77–80: um servidor simulado que responde após um atraso aleatório). Se um novo texto chegar antes da resposta, a busca anterior é abandonada: sua resposta nunca será exibida. Com o cliente HTTP real, a requisição seria até cancelada;
- linha 52: o signal [results] é uma lista vazia enquanto nenhuma busca tiver sido bem-sucedida.
| <div class="container py-4" style="max-width: 720px">
<h1 class="h3 mb-3">Example 19 - RxJS observables</h1>
<div class="card p-3 mb-3">
<h2 class="h6">A countdown (interval, take, map, toSignal)</h2>
<p class="display-6 mb-0">{{ countdown() }}</p>
</div>
<div class="card p-3 mb-3">
<h2 class="h6">A search as you type (debounceTime, switchMap)</h2>
<input class="form-control mb-2" placeholder="at least two letters: pel, dur..." (input)="onInput(field.value)" #field>
<ul class="mb-0">
@for (r of results(); track r) {
<li>{{ r }}</li>
} @empty {
<li class="text-muted">no result</li>
}
</ul>
</div>
<h2 class="h6">Log</h2>
<ol class="small">
@for (line of log(); track $index) {
<li>{{ line }}</li>
}
</ol>
</div>
|
- linha 6: a contagem regressiva, um signal;
- linha 11: [#field] é uma variável de template: ela se refere ao elemento [<input>], cujo valor é passado a cada tecla digitada;
- linhas 13–17: os resultados da busca.
[npm start 19-rxjs]; digite “pe” e, um pouco depois, “l”:

O log mostra as duas buscas: “pe” (enviada após 400 ms de silêncio) e depois “pel”.
Signals ou observables? Ambos coexistem no [Angular], com papéis diferentes:
| | Signal | Observable |
Valor | sempre tem um valor atual, que pode ser lido a qualquer momento | emite valores ao longo do tempo; sem valor “atual” |
Uso | o estado da aplicação (o que é exibido) | eventos e operações assíncronas (requisições, temporizadores, teclas digitadas) |
Inscrição | automática (templates, [computed], [effect]) | explícita ([subscribe]) ou por meio de [toSignal] |
Principais características | Simplicidade | Operadores: esperar, combinar, abandonar |
A tendência no [Angular] é armazenar o estado em signals e reservar os observables para os casos em que seus operadores são úteis. [toSignal] e [toObservable] permitem alternar entre os dois. No estudo de caso, as requisições HTTP serão convertidas em promises ([firstValueFrom], Exemplo 22), e o estado será encapsulado em signals; apenas os eventos do roteador serão escutados como observables.
5.2. Exemplo 20: um estado compartilhado
Vários componentes costumam precisar dos mesmos dados: o usuário conectado (a barra de navegação, os guards, as páginas), as mensagens a exibir e o idioma selecionado. Onde armazenar esses dados? O curso de [NestJS] tratou da mesma questão no lado do servidor (escopos de aplicação, de requisição e de sessão). Este exemplo a adapta ao navegador, com três “escopos”:
- o estado local de um componente, armazenado em suas próprias variáveis: ele desaparece quando o componente é destruído;
- o estado de um serviço root: compartilhado por todos os componentes, ele sobrevive à remoção deles, mas não a uma recarga da página (F5), que reinicia a aplicação;
- o estado armazenado no localStorage do navegador: ele sobrevive a uma recarga da página e até ao fechamento do navegador.
| 20-shared-state/src/app/
├── state/
│ ├── cart.service.ts a shared state
│ └── preferences.service.ts a state that survives F5
├── components/
│ ├── shop.ts adds to the cart
│ ├── cart-summary.ts displays the cart
│ └── local-counter.ts a local state
├── app.ts
└── app.html
|
5.2.1. Um serviço que contém o estado
| // =========================================================================
// 20-shared-state/src/app/state/cart.service.ts - um ESTADO COMPARTILHADO
// -------------------------------------------------------------------------
// Um serviço raiz (providedIn: 'root') que contém signals é uma
// "store": UMA única instância para a aplicação inteira, que
// todos os componentes compartilham. Organização habitual:
// - o ESTADO: signals PRIVADOS, modificáveis apenas pelo serviço;
// - signals SOMENTE LEITURA (asReadonly) e computeds, lidos pelos
// componentes;
// - métodos (as "ações"), os únicos que modificam o estado.
// O serviço vive enquanto a aplicação viver: ele sobrevive à remoção de um
// componente... mas não ao recarregamento da página (F5), que reinicia
// a aplicação. (Não é preciso uma biblioteca adicional, como o Pinia
// do Vue.js: serviços e signals bastam.)
// =========================================================================
import { computed, Injectable, signal } from '@angular/core';
export interface Item {
label: string;
price: number;
}
@Injectable({ providedIn: 'root' })
export class CartService {
private readonly _items = signal<Item[]>([]);
readonly items = this._items.asReadonly();
readonly count = computed(() => this._items().length);
readonly total = computed(() => this._items().reduce((s, a) => s + a.price, 0));
add(item: Item): void {
this._items.update((a) => [...a, item]);
}
clear(): void {
this._items.set([]);
}
}
|
Um serviço root que contém signals atua como um store ([store]): uma única instância, compartilhada por toda a aplicação. Ele se organiza em três partes:
- linha 26: o estado, em um signal privado: nenhum componente pode modificá-lo diretamente;
- linhas 28–30: o que os componentes leem: o estado somente leitura ([asReadonly]) e os valores calculados ([computed]);
- linhas 32–38: as ações, os únicos métodos que podem modificar o estado.
Essa abordagem tem uma vantagem fundamental: quando um carrinho de compras é inválido, as únicas modificações possíveis ocorrem dentro dos métodos do serviço. Com o [Vue.js], costuma-se usar uma biblioteca ([Pinia]) para esse fim; com o [Angular], bastam serviços e signals.
5.2.2. Componentes que o compartilham
| // 20-shared-state/src/app/components/shop.ts - ADICIONA ao carrinho compartilhado
import { Component, inject } from '@angular/core';
import { Item, CartService } from '../state/cart.service';
@Component({
selector: 'app-shop',
template: `
<div class="card p-3 h-100">
<h2 class="h6">Shop</h2>
@for (p of products; track p.label) {
<button class="btn btn-sm btn-outline-primary mb-2" (click)="cart.add(p)">+ {{ p.label }} (€{{ p.price }})</button>
}
</div>
`,
})
export class Shop {
protected readonly cart = inject(CartService);
protected readonly products: Item[] = [
{ label: 'Consultation', price: 30 },
{ label: 'Vaccine', price: 12.5 },
];
}
|
- linha 17: o componente injeta o serviço;
- linha 11: ele chama uma ação.
| // 20-shared-state/src/app/components/cart-summary.ts - LÊ o mesmo carrinho
import { Component, inject } from '@angular/core';
import { CartService } from '../state/cart.service';
@Component({
selector: 'app-cart-summary',
template: `
<div class="card p-3 h-100">
<h2 class="h6">Cart</h2>
<p class="mb-2">{{ cart.count() }} item(s), €{{ cart.total() }}</p>
<button class="btn btn-sm btn-outline-danger align-self-start" [disabled]="cart.count() === 0"
(click)="cart.clear()">Clear</button>
</div>
`,
})
export class CartSummary {
protected readonly cart = inject(CartService);
}
|
- linha 10: ele lê os valores calculados do mesmo serviço;
- linha 12: ele chama outra ação.
Os dois componentes não sabem da existência um do outro: não há entradas nem saídas entre eles. Eles se comunicam por meio do serviço.
| // 20-shared-state/src/app/components/local-counter.ts - um estado LOCAL, que desaparece com o componente
import { Component, signal } from '@angular/core';
@Component({
selector: 'app-local-counter',
template: `
<div class="card p-3 h-100">
<h2 class="h6">Local state</h2>
<button class="btn btn-sm btn-outline-secondary align-self-start" (click)="clicks.set(clicks() + 1)">{{ clicks() }} click(s)</button>
</div>
`,
})
export class LocalCounter {
protected readonly clicks = signal(0);
}
|
- linha 14: um estado local: cada instância do componente tem seu próprio contador, que desaparece quando a instância é destruída.
5.2.3. Um estado que sobrevive à recarga da página
| // =========================================================================
// 20-shared-state/src/app/state/preferences.service.ts - um estado que sobrevive ao F5
// -------------------------------------------------------------------------
// Para que um dado sobreviva ao recarregamento da página ou ao fechamento
// do navegador, ele deve ser armazenado NO navegador: localStorage (um
// pequeno dicionário chave -> string, específico de cada site).
// - na partida, o serviço lê o localStorage de novo;
// - um effect reescreve o localStorage a cada mudança.
// NUNCA armazenamos dados sensíveis ali (senha, token): qualquer script
// da página pode ler o localStorage.
// =========================================================================
import { effect, Injectable, signal } from '@angular/core';
const KEY = 'example20.preferences';
export interface Preferences {
dark: boolean;
size: number; // tamanho do texto, em px
}
function read(): Preferences {
try {
return { dark: false, size: 16, ...JSON.parse(localStorage.getItem(KEY) ?? '{}') };
} catch {
return { dark: false, size: 16 }; // conteúdo ilegível: valores padrão
}
}
@Injectable({ providedIn: 'root' })
export class PreferencesService {
readonly preferences = signal<Preferences>(read());
constructor() {
effect(() => localStorage.setItem(KEY, JSON.stringify(this.preferences())));
}
// uma preferência muda: substituímos o objeto (o signal percebe)
update(change: Partial<Preferences>): void {
this.preferences.update((p) => ({ ...p, ...change }));
}
}
|
- linha 15: a chave sob a qual as preferências são armazenadas no [localStorage], um pequeno dicionário de chave para string específico de cada site;
- linhas 22–28: na inicialização, as preferências salvas são lidas. Os valores padrão são complementados pelos que foram salvos (com o operador [...]); conteúdo ilegível é ignorado (linha 26);
- linha 32: as preferências, em um signal;
- linha 35: um effect (exemplo 13) reescreve o [localStorage] sempre que o signal muda: não é preciso pensar nisso em cada ação;
- linhas 39–41: a ação que modifica uma ou mais preferências ([Partial<Preferences>]: um objeto em que toda propriedade é opcional). Substituímos o objeto em vez de modificá-lo: um signal só detecta mudanças de valor.
Dados sensíveis (senhas, tokens de login) nunca são armazenados no [localStorage]: qualquer script executado pela página pode lê-los. É por isso que o token de login da aplicação [RdvMedecins] será armazenado em um cookie, inacessível ao código [JavaScript].
5.2.4. A página
| // =========================================================================
// 20-shared-state/src/app/app.ts - três "escopos" de dados no lado do cliente
// -------------------------------------------------------------------------
// Mesma questão do exemplo 23 do curso de NestJS (escopo de aplicação,
// de requisição, de cliente), transposta para o navegador:
// - o estado LOCAL de um componente (LocalCounter) desaparece com ele;
// - o estado de um SERVIÇO raiz (o carrinho) é compartilhado por todos os
// componentes e sobrevive à remoção deles - mas não ao F5;
// - o estado armazenado no localStorage (as preferências) sobrevive ao F5 e ao
// fechamento do navegador.
// Desmarque e marque de novo "show the area", depois recarregue a página: compare.
// =========================================================================
import { Component, inject, signal } from '@angular/core';
import { PreferencesService } from './state/preferences.service';
import { Shop } from './components/shop';
import { CartSummary } from './components/cart-summary';
import { LocalCounter } from './components/local-counter';
@Component({
selector: 'app-root',
imports: [Shop, CartSummary, LocalCounter],
templateUrl: './app.html',
})
export class App {
protected readonly prefs = inject(PreferencesService);
protected readonly areaVisible = signal(true);
}
|
- linha 27: um estado local do componente raiz: a área está exibida?
| @let p = prefs.preferences();
<div class="min-vh-100" [class.bg-dark]="p.dark" [class.text-light]="p.dark" [style.font-size.px]="p.size">
<div class="container py-4">
<h1 class="h3 mb-3">Example 20 - shared state</h1>
<div class="d-flex flex-wrap gap-4 mb-3">
<label class="form-check-label">
<input #dark type="checkbox" class="form-check-input" [checked]="p.dark"
(change)="prefs.update({ dark: dark.checked })"> dark theme
</label>
<label>
text size
<input #size type="range" min="12" max="22" [value]="p.size"
(input)="prefs.update({ size: +size.value })"> {{ p.size }} px
</label>
<label class="form-check-label">
<input #area type="checkbox" class="form-check-input" [checked]="areaVisible()"
(change)="areaVisible.set(area.checked)"> show the area
</label>
</div>
@if (areaVisible()) {
<div class="row g-3 text-body">
<div class="col-md-4"><app-shop /></div>
<div class="col-md-4"><app-cart-summary /></div>
<div class="col-md-4"><app-local-counter /></div>
</div>
}
<p class="mt-3 mb-2">Outside the area, a second summary of the SAME cart (it stays there when the area disappears):</p>
<div class="text-body"><app-cart-summary /></div>
</div>
</div>
|
- linha 1: [@let] declara uma variável de template: [p] evita repetir [prefs.preferences()];
- Linha 2: as preferências se aplicam à página inteira: [[class.bg-dark]] define a classe se o valor for true; [[style.font-size.px]] define um tamanho em pixels;
- Linhas 7–8 e 12–13: cada alteração dispara a ação [update];
- Linhas 20–26: a área que contém os três componentes, exibida ou não;
- linha 28: um segundo resumo do mesmo carrinho de compras, fora da área.
[npm start 20-shared-state]; dois itens são adicionados ao carrinho de compras e o contador local é clicado duas vezes:

Você pode então verificar os três escopos:
- desmarque e marque novamente “show the area”: o contador local voltou a 0 (o componente foi recriado), o carrinho de compras está intacto (o serviço sobreviveu);
- selecione o tema escuro e recarregue a página (F5): o carrinho de compras está vazio (a aplicação foi reiniciada), o tema escuro é mantido (o [localStorage] sobreviveu).