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.

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#
signalguarda estado. Lê chamando (count()), muda comsetouupdate.computedderiva um valor de outros signals. É preguiçoso, guarda o resultado e não pode ser alterado.effecté pra efeito colateral: salvar nolocalStorage, 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.httpResourcebusca dados e refaz a busca sozinho quando os signals que ele lê mudam.- No Angular 22,
httpResource,rxResourcee os Signal Forms são API estável, e oOnPushé o padrão. - Nunca altere objeto ou array no lugar.
items().push(x)não avisa ninguém. Useupdatecom 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: 6No 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(); // 30Três coisas que o teste confirma:
- É preguiçoso. A função só roda quando alguém lê
total(). Criar ocomputednã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 valueEle 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:
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.httpResourcelêquery()e, a cada mudança, faz a requisição de novo. Se a função devolveundefined, ele não faz requisição nenhuma: é assim que a busca espera ter pelo menos duas letras. Ele expõevalue(),isLoading()eerror()como signals.counté umcomputedsimples em cima do resultado.selectedé umlinkedSignalcom 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
effectsalva a última busca nolocalStorage, que é coisa de fora do Angular.
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:
| Antes | Agora | O que é |
|---|---|---|
@Input() name | name = input<string>() | entrada do componente, lida com name() |
@Input({ required: true }) | input.required<string>() | entrada obrigatória, erro no build se faltar |
@Output() + EventEmitter | output<string>() | evento (não é signal, mas segue o mesmo estilo) |
@Input + @Output xChange | model<string>() | valor nos dois sentidos com [(x)] |
@ViewChild('ref') | viewChild<ElementRef>('ref') | consulta ao template, lida como signal |
Um exemplo de viewChild:
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:
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 } }),
});
}toSignaltransforma um Observable em signal. Aqui, o evento deresizeda janela vira um valor que o template lê.toObservablefaz o caminho inverso, pra aplicardebounceTimenum 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:
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
setTimeoute 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: ocomputedque depende da lista continua com o tamanho antigo. Useitems.update((list) => [...list, x]). effectpra sincronizar estado. Se ele só fazoutro.set(...), écomputedoulinkedSignal.- Ler signal depois de um
await. Dentro decomputedeeffect, só conta como dependência o que foi lido de forma síncrona. O que vem depois de umawaitnã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 emcomputed, efeitos de fora emeffect. - Nenhum
effectque só copia valor pra outro signal. - Arrays e objetos sempre trocados por novos, com
update. - Dados do servidor com
httpResourceourxResource, tratandoisLoading()eerror(). linkedSignalpra escolha do usuário que depende de uma lista.- Inputs com
input()einput.required(), eventos comoutput(), dois sentidos commodel(). - RxJS só onde há fluxo no tempo, ligado por
toSignaletoObservable. - Formulários novos com Signal Forms.
Referências#
Comentários
Pra comentar, entre com sua conta do GitHub.
Leia também

Front-end8 min de leitura
camelCase, PascalCase, kebab-case e snake_case: quando usar

Front-end12 min de leitura
Smart e dumb components no Angular e no React, em 2026

Front-end10 min de leitura
Storybook: como começar e até onde vale a pena ir