Todos os artigos

Front-end10 min de leitura

Signals no Angular 22: signal, computed, effect e além

Guia prático de signals no Angular 22: signal, computed, effect, linkedSignal, httpResource, Signal Forms, RxJS e os erros que mais aparecem, com código testado.

Também em English, Español, Français

Signals chegaram no Angular 16 como novidade e, no Angular 22, viraram a base de quase tudo: inputs, consultas ao template, chamadas HTTP, formulários e a própria detecção de mudanças. Quem ainda escreve Angular só com @Input, BehaviorSubject e async pipe está usando um framework que já mudou por baixo.

Este post vai do básico ao que entrou de estável agora: signal, computed, effect, linkedSignal, httpResource, signals nos componentes, a ponte com RxJS e os Signal Forms. No fim, os erros que mais aparecem.

Um aviso honesto: todo o código foi compilado no Angular 22.3, e cada comportamento que o texto afirma tem um teste que passa, inclusive uma pegadinha que eu só descobri porque o teste falhou.

TL;DR#

  • signal guarda estado. Lê chamando (count()), muda com set ou update.
  • computed deriva um valor de outros signals. É preguiçoso, guarda o resultado e não pode ser alterado.
  • effect é pra efeito colateral: salvar no localStorage, chamar uma biblioteca de fora. Nunca pra mudar outro signal.
  • linkedSignal é um derivado que você também pode alterar, e que volta ao valor calculado quando a origem muda.
  • httpResource busca dados e refaz a busca sozinho quando os signals que ele lê mudam.
  • No Angular 22, httpResource, rxResource e os Signal Forms são API estável, e o OnPush é o padrão.
  • Nunca altere objeto ou array no lugar. items().push(x) não avisa ninguém. Use update com um array novo.

Por que signals#

Antes, o Angular descobria o que mudou rodando a detecção de mudanças na árvore inteira, com a ajuda do zone.js. Um signal inverte isso: ele sabe quem depende dele. Quando muda, avisa só esses dependentes, e o Angular atualiza só aquele pedaço da tela.

Na prática, isso dá três coisas:

  • Menos trabalho na tela, porque o Angular não precisa verificar componentes que não dependem do que mudou.
  • Código mais previsível, porque um valor derivado se recalcula sozinho e não fica desatualizado.
  • Menos RxJS pra coisas simples. Estado de tela vira signal. RxJS continua ótimo pra fluxo de eventos ao longo do tempo.

signal: o estado#

import { signal } from '@angular/core';
 
const count = signal(0);
 
count();                     // 0: reading is calling
count.set(5);                // replaces the value
count.update((n) => n + 1);  // computes the next one from the current: 6

No template, a leitura é igual: {{ count() }}. Esquecer os parênteses é o erro número um de quem está começando.

computed: o valor derivado#

const price = signal(10);
const quantity = signal(2);
const total = computed(() => price() * quantity());
 
total();          // 20
quantity.set(3);
total();          // 30

Três coisas que o teste confirma:

  • É preguiçoso. A função só roda quando alguém lê total(). Criar o computed não executa nada.
  • Guarda o resultado. Ler total() duas vezes seguidas roda a conta uma vez só.
  • Só recalcula quando uma dependência muda. E ele descobre as dependências sozinho, pelos signals que leu.

E não tem set: valor derivado não se altera na mão. Se você sente vontade de alterar um computed, provavelmente quer um linkedSignal (mais abaixo).

effect: o efeito colateral#

effect(() => {
  localStorage.setItem('last-query', query());
});

O effect roda uma vez e roda de novo sempre que um signal que ele leu muda. Ele existe pra conversar com o mundo de fora do Angular: localStorage, um gráfico desenhado por uma biblioteca, um log.

O uso errado mais comum é esse:

// Don't: an effect that keeps another signal in sync.
effect(() => total.set(price() * quantity()));
 
// Do: derived state is a computed.
const total = computed(() => price() * quantity());

Se o effect só serve pra copiar ou calcular um valor e jogar em outro signal, troque por computed ou linkedSignal. O resultado é o mesmo, sem um ciclo extra e sem chance de ficar fora de ordem.

untracked: ler sem depender#

Às vezes você quer ler um signal dentro de um effect sem que ele dispare o effect:

effect(() => {
  console.log(`search: ${query()}, page: ${untracked(page)}`);
});

Aqui, mudar query roda o efeito. Mudar page não roda, mas quando o efeito roda ele lê o page atual.

linkedSignal: derivado que você pode mudar#

O caso clássico: uma lista de opções e a opção escolhida. A escolha é do usuário, mas se a lista mudar, a escolha precisa voltar pra um valor que faça sentido.

const options = signal(['small', 'medium', 'large']);
const choice = linkedSignal(() => options()[0]);
 
choice.set('large');            // the user picked one
options.set(['xs', 'xl']);      // the list changed
choice();                       // 'xs': back to the computed value

Ele aceita uma forma mais completa, com acesso ao valor anterior, que aparece no exemplo da próxima seção.

httpResource: dados que se buscam sozinhos#

Juntando tudo num componente de busca de produtos:

product-search.ts
import { httpResource } from '@angular/common/http';
import { Component, computed, effect, linkedSignal, signal } from '@angular/core';
import { Product } from './product';
 
@Component({
  selector: 'app-product-search',
  template: `
    <input #searchBox [value]="query()" (input)="query.set(searchBox.value)" placeholder="Search products" />
 
    @if (products.isLoading()) {
      <p>Searching...</p>
    } @else {
      <p>{{ count() }} results</p>
      @for (product of products.value(); track product.id) {
        <button type="button" [class.selected]="product.id === selected()?.id" (click)="selected.set(product)">
          {{ product.name }}
        </button>
      }
    }
 
    @if (selected(); as product) {
      <p class="selected-name">Selected: {{ product.name }}</p>
    }
  `,
})
export class ProductSearch {
  // State: the source of truth, changed with set() or update().
  protected readonly query = signal(localStorage.getItem('last-query') ?? '');
 
  // Async data: refetches on its own whenever query() changes. Below 2 letters, no request.
  protected readonly products = httpResource<Product[]>(
    () => {
      const q = this.query().trim();
      return q.length < 2 ? undefined : { url: '/api/products', params: { q } };
    },
    { defaultValue: [] },
  );
 
  // Derived and read-only: recalculated only when products change.
  protected readonly count = computed(() => this.products.value().length);
 
  // Derived but writable: the user picks one, and a new result list resets the choice
  // (keeping it only if the same product is still in the list). While a new search is
  // loading, value() falls back to defaultValue, so that moment is ignored (null source).
  protected readonly selected = linkedSignal<Product[] | null, Product | null>({
    source: () => (this.products.isLoading() ? null : this.products.value()),
    computation: (products, previous) => {
      if (products === null) return previous?.value ?? null;
      return products.find((p) => p.id === previous?.value?.id) ?? null;
    },
  });
 
  constructor() {
    // Side effect: talks to something outside Angular. Never use it to set another signal.
    effect(() => localStorage.setItem('last-query', this.query()));
  }
}

O que acontece aqui:

  • query é o estado: o texto digitado.
  • httpResource lê query() e, a cada mudança, faz a requisição de novo. Se a função devolve undefined, ele não faz requisição nenhuma: é assim que a busca espera ter pelo menos duas letras. Ele expõe value(), isLoading() e error() como signals.
  • count é um computed simples em cima do resultado.
  • selected é um linkedSignal com acesso ao valor anterior: o usuário escolhe um produto, e quando chega uma lista nova a escolha só continua se o mesmo produto ainda estiver nela.
  • O effect salva a última busca no localStorage, que é coisa de fora do Angular.
Cada valor sabe de quem depende. Mudou o query, só o que depende dele se mexe

A pegadinha que o teste pegou#

Na primeira versão, o linkedSignal usava products.value() direto como origem, e a seleção sumia toda vez que o usuário refinava a busca, mesmo com o produto ainda na lista nova.

O motivo: enquanto o httpResource busca de novo, value() volta pro defaultValue, a lista vazia. O linkedSignal via a lista vazia, não achava o produto e zerava a escolha. Quando os resultados chegavam, o valor anterior já era null.

A correção está no código acima: enquanto isLoading() é verdadeiro, a origem vira null, e a função mantém o valor anterior. Vale pra qualquer valor derivado de um resource: lembre que existe esse momento intermediário.

Signals nos componentes#

As APIs de componente agora são signals também:

AntesAgoraO que é
@Input() namename = input<string>()entrada do componente, lida com name()
@Input({ required: true })input.required<string>()entrada obrigatória, erro no build se faltar
@Output() + EventEmitteroutput<string>()evento (não é signal, mas segue o mesmo estilo)
@Input + @Output xChangemodel<string>()valor nos dois sentidos com [(x)]
@ViewChild('ref')viewChild<ElementRef>('ref')consulta ao template, lida como signal

Um exemplo de viewChild:

toolbar.ts
import { Component, ElementRef, viewChild } from '@angular/core';
 
@Component({
  selector: 'app-toolbar',
  template: `<input #search placeholder="Search" /> <button type="button" (click)="focusSearch()">Focus</button>`,
})
export class Toolbar {
  // Signal query: the element is read like any other signal.
  private readonly search = viewChild.required<ElementRef<HTMLInputElement>>('search');
 
  protected focusSearch() {
    this.search().nativeElement.focus();
  }
}

Como input() é um signal, dá pra usar dentro de computed, e o componente reage sozinho quando o pai muda o valor. Não precisa mais de ngOnChanges pra isso.

Signals e RxJS#

Signals não substituem RxJS. Eles cobrem estado. RxJS continua melhor pra fluxo de eventos ao longo do tempo: debounce, cancelar requisição anterior, juntar fontes. A ponte é o pacote @angular/core/rxjs-interop:

rx-interop.ts
import { HttpClient } from '@angular/common/http';
import { Component, inject, signal } from '@angular/core';
import { rxResource, toObservable, toSignal } from '@angular/core/rxjs-interop';
import { debounceTime, distinctUntilChanged, fromEvent, map } from 'rxjs';
import { Product } from './product';
 
@Component({
  selector: 'app-rx-interop',
  template: `
    <p>Window width: {{ width() }}px</p>
    <input #box (input)="term.set(box.value)" />
    <p>{{ results.value()?.length ?? 0 }} results</p>
  `,
})
export class RxInterop {
  private readonly http = inject(HttpClient);
 
  // Observable to signal: a stream of browser events becomes a value the template reads.
  protected readonly width = toSignal(
    fromEvent(window, 'resize').pipe(map(() => window.innerWidth)),
    { initialValue: window.innerWidth },
  );
 
  // Signal to observable: use RxJS where it shines, like debounce.
  protected readonly term = signal('');
  private readonly debouncedTerm = toSignal(
    toObservable(this.term).pipe(debounceTime(300), distinctUntilChanged()),
    { initialValue: '' },
  );
 
  // A resource whose loader returns an Observable.
  protected readonly results = rxResource({
    params: () => this.debouncedTerm() || undefined,
    stream: ({ params }) => this.http.get<Product[]>('/api/products', { params: { q: params } }),
  });
}
  • toSignal transforma um Observable em signal. Aqui, o evento de resize da janela vira um valor que o template lê.
  • toObservable faz o caminho inverso, pra aplicar debounceTime num signal.
  • rxResource é um resource cujo carregamento devolve um Observable. Estável desde o Angular 22.

Signal Forms#

Desde o Angular 22, formulários também têm uma versão com signals, e ela é API estável. O modelo é um signal comum, e o formulário lê e escreve direto nele:

sign-up-form.ts
import { Component, signal } from '@angular/core';
import { email, form, FormField, minLength, required } from '@angular/forms/signals';
 
interface SignUp {
  name: string;
  email: string;
  password: string;
}
 
@Component({
  selector: 'app-sign-up-form',
  imports: [FormField],
  template: `
    <label>Name <input [formField]="signUpForm.name" /></label>
    <label>Email <input type="email" [formField]="signUpForm.email" /></label>
    @for (error of signUpForm.email().errors(); track error.kind) {
      <p class="error">{{ error.message }}</p>
    }
    <label>Password <input type="password" [formField]="signUpForm.password" /></label>
    @for (error of signUpForm.password().errors(); track error.kind) {
      <p class="error">{{ error.message }}</p>
    }
    <button type="button" [disabled]="!signUpForm().valid()">Create account</button>
  `,
})
export class SignUpForm {
  // The model is a plain signal: the form reads and writes straight into it.
  protected readonly model = signal<SignUp>({ name: '', email: '', password: '' });
 
  protected readonly signUpForm = form(this.model, (path) => {
    required(path.name, { message: 'Tell us your name' });
    required(path.email, { message: 'Email is required' });
    email(path.email, { message: 'Enter a valid email' });
    minLength(path.password, 8, { message: 'Use at least 8 characters' });
  });
}
  • form(model, regras) cria uma árvore de campos com o mesmo formato do modelo.
  • As regras (required, email, minLength) ficam numa função, longe do template.
  • [formField] liga cada campo a um <input>, nos dois sentidos.
  • Estado de cada campo é signal: signUpForm.email().errors(), signUpForm().valid().

Reactive Forms continuam funcionando. Pra formulário novo, os Signal Forms são mais curtos e conversam direto com o resto do código em signals.

E o OnPush e o zone.js?#

Duas consequências diretas de tudo isso no Angular 22:

  • OnPush é o padrão. O componente só é verificado quando um input muda, um evento acontece no template ou um signal que ele lê muda. Com signals, isso funciona sem você pensar.
  • Projetos novos nascem sem zone.js. O Angular não precisa mais interceptar todo setTimeout e toda promise pra saber que algo mudou: os signals avisam.

Isso também explica o erro mais chato de quem migra: estado guardado em propriedade comum, mudado dentro de um setTimeout, pode não aparecer na tela. A solução é guardar em signal.

Erros comuns#

  • Esquecer os parênteses. {{ count }} mostra a função, não o valor. É {{ count() }}.
  • Alterar no lugar. items().push(x) não avisa ninguém, e o teste confirma: o computed que depende da lista continua com o tamanho antigo. Use items.update((list) => [...list, x]).
  • effect pra sincronizar estado. Se ele só faz outro.set(...), é computed ou linkedSignal.
  • Ler signal depois de um await. Dentro de computed e effect, só conta como dependência o que foi lido de forma síncrona. O que vem depois de um await não é rastreado.
  • Esquecer o momento de carregamento. Valor derivado de resource passa pelo estado de carregando, quando value() volta pro padrão.
  • Trocar todo RxJS por signals. Debounce, cancelamento e combinação de fluxos continuam sendo trabalho de RxJS.

Checklist#

  • Estado em signal, derivados em computed, efeitos de fora em effect.
  • Nenhum effect que só copia valor pra outro signal.
  • Arrays e objetos sempre trocados por novos, com update.
  • Dados do servidor com httpResource ou rxResource, tratando isLoading() e error().
  • linkedSignal pra escolha do usuário que depende de uma lista.
  • Inputs com input() e input.required(), eventos com output(), dois sentidos com model().
  • RxJS só onde há fluxo no tempo, ligado por toSignal e toObservable.
  • Formulários novos com Signal Forms.

Referências#

  • Front-end
  • angular
  • signals
  • rxjs
  • formularios
  • typescript

Escrito por

Engenheira de software e designer. Escrevo sobre o que encontro construindo apps, APIs e produtos.

Comentários

Pra comentar, entre com sua conta do GitHub.