Skip to content

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”:

Image

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:

Image

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).