Front-end10 min de lectura
Signals en Angular 22: signal, computed, effect y más
Guía práctica de signals en Angular 22: signal, computed, effect, linkedSignal, httpResource, Signal Forms, RxJS y los errores más comunes, con código probado.

Los signals llegaron en Angular 16 como novedad y, en Angular 22, se volvieron la base de casi todo: inputs, consultas al template, llamadas HTTP, formularios y la propia detección de cambios. Si todavía escribes Angular solo con @Input, BehaviorSubject y el pipe async, estás usando un framework que ya cambió por debajo.
Este post va de lo básico a lo que acaba de volverse estable: signal, computed, effect, linkedSignal, httpResource, signals en los componentes, el puente con RxJS y los Signal Forms. Al final, los errores más comunes.
Un aviso honesto: todo el código se compiló en Angular 22.3, y cada comportamiento que el texto afirma tiene una prueba que pasa, incluida una trampa que solo descubrí porque la prueba falló.
TL;DR#
signalguarda estado. Se lee llamándolo (count()), se cambia consetoupdate.computedderiva un valor de otros signals. Es perezoso, guarda el resultado y no se puede modificar.effectes para efectos secundarios: guardar enlocalStorage, llamar a una biblioteca externa. Nunca para cambiar otro signal.linkedSignales un derivado que también puedes modificar, y que vuelve al valor calculado cuando cambia su origen.httpResourcebusca datos y vuelve a buscar solo cuando cambian los signals que lee.- En Angular 22,
httpResource,rxResourcey los Signal Forms son API estable, yOnPushes el predeterminado. - Nunca modifiques un objeto o un array en el lugar.
items().push(x)no avisa a nadie. Usaupdatecon un array nuevo.
Por qué signals#
Antes, Angular descubría qué había cambiado recorriendo la detección de cambios en todo el árbol, con ayuda de zone.js. Un signal lo invierte: sabe quién depende de él. Cuando cambia, avisa solo a esos dependientes, y Angular actualiza solo esa parte de la pantalla.
En la práctica, eso da tres cosas:
- Menos trabajo en pantalla, porque Angular no necesita revisar componentes que no dependen de lo que cambió.
- Código más predecible, porque un valor derivado se recalcula solo y nunca queda desactualizado.
- Menos RxJS para cosas simples. El estado de pantalla pasa a ser signal. RxJS sigue siendo excelente para flujos de eventos en el tiempo.
signal: el 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: 6En el template, la lectura es igual: {{ count() }}. Olvidar los paréntesis es el error número uno de quien empieza.
computed: el valor derivado#
const price = signal(10);
const quantity = signal(2);
const total = computed(() => price() * quantity());
total(); // 20
quantity.set(3);
total(); // 30Tres cosas que la prueba confirma:
- Es perezoso. La función solo corre cuando alguien lee
total(). Crear elcomputedno ejecuta nada. - Guarda el resultado. Leer
total()dos veces seguidas hace la cuenta una sola vez. - Solo recalcula cuando cambia una dependencia. Y descubre sus dependencias solo, por los signals que leyó.
Y no tiene set: un valor derivado no se cambia a mano. Si sientes ganas de cambiar un computed, probablemente quieres un linkedSignal (más abajo).
effect: el efecto secundario#
effect(() => {
localStorage.setItem('last-query', query());
});El effect corre una vez y vuelve a correr cada vez que cambia un signal que leyó. Existe para hablar con el mundo fuera de Angular: localStorage, un gráfico dibujado por una biblioteca, un log.
El mal uso más común es este:
// 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());Si el effect solo copia o calcula un valor y lo pone en otro signal, cámbialo por computed o linkedSignal. El resultado es el mismo, sin un ciclo extra y sin riesgo de quedar fuera de orden.
untracked: leer sin depender#
A veces quieres leer un signal dentro de un effect sin que dispare el effect:
effect(() => {
console.log(`search: ${query()}, page: ${untracked(page)}`);
});Aquí, cambiar query ejecuta el efecto. Cambiar page no, pero cuando el efecto corre, lee el page actual.
linkedSignal: un derivado que puedes cambiar#
El caso clásico: una lista de opciones y la opción elegida. La elección es del usuario, pero si la lista cambia, la elección tiene que volver a un valor que tenga 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 valueTambién acepta una forma más completa, con acceso al valor anterior, que aparece en el ejemplo de la próxima sección.
httpResource: datos que se buscan solos#
Juntando todo en un componente de búsqueda de productos:
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()));
}
}Qué pasa aquí:
queryes el estado: el texto escrito.httpResourceleequery()y, en cada cambio, vuelve a hacer la petición. Si la función devuelveundefined, no hace ninguna petición: así la búsqueda espera tener al menos dos letras. Exponevalue(),isLoading()yerror()como signals.countes uncomputedsimple sobre el resultado.selectedes unlinkedSignalcon acceso al valor anterior: el usuario elige un producto, y cuando llega una lista nueva la elección solo se mantiene si el mismo producto sigue en ella.- El
effectguarda la última búsqueda enlocalStorage, que está fuera de Angular.
La trampa que atrapó la prueba#
En la primera versión, el linkedSignal usaba products.value() directamente como origen, y la selección desaparecía cada vez que el usuario refinaba la búsqueda, aunque el producto siguiera en la lista nueva.
El motivo: mientras httpResource vuelve a buscar, value() vuelve al defaultValue, la lista vacía. El linkedSignal veía la lista vacía, no encontraba el producto y borraba la elección. Cuando llegaban los resultados, el valor anterior ya era null.
La corrección está en el código de arriba: mientras isLoading() es verdadero, el origen pasa a ser null, y la función mantiene el valor anterior. Vale para cualquier valor derivado de un resource: recuerda que existe ese momento intermedio.
Signals en los componentes#
Las APIs de componente ahora también son signals:
| Antes | Ahora | Qué es |
|---|---|---|
@Input() name | name = input<string>() | entrada del componente, se lee con name() |
@Input({ required: true }) | input.required<string>() | entrada obligatoria, error en el build si falta |
@Output() + EventEmitter | output<string>() | evento (no es signal, pero sigue el mismo estilo) |
@Input + @Output xChange | model<string>() | valor en los dos sentidos con [(x)] |
@ViewChild('ref') | viewChild<ElementRef>('ref') | consulta al template, se lee como signal |
Un ejemplo 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() es un signal, puedes usarlo dentro de computed, y el componente reacciona solo cuando el padre cambia el valor. Ya no hace falta ngOnChanges para eso.
Signals y RxJS#
Los signals no reemplazan a RxJS. Cubren el estado. RxJS sigue siendo mejor para flujos de eventos en el tiempo: debounce, cancelar la petición anterior, combinar fuentes. El puente es el paquete @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 } }),
});
}toSignalconvierte un Observable en signal. Aquí, el eventoresizede la ventana pasa a ser un valor que el template lee.toObservablehace el camino inverso, para aplicardebounceTimea un signal.rxResourcees un resource cuya carga devuelve un Observable. Estable desde Angular 22.
Signal Forms#
Desde Angular 22, los formularios también tienen una versión con signals, y es API estable. El modelo es un signal común, y el formulario lee y escribe directamente en él:
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(modelo, reglas)crea un árbol de campos con la misma forma que el modelo.- Las reglas (
required,email,minLength) quedan en una función, lejos del template. [formField]conecta cada campo con un<input>, en los dos sentidos.- El estado de cada campo es signal:
signUpForm.email().errors(),signUpForm().valid().
Los Reactive Forms siguen funcionando. Para un formulario nuevo, los Signal Forms son más cortos y hablan directo con el resto del código en signals.
¿Y OnPush y zone.js?#
Dos consecuencias directas de todo esto en Angular 22:
OnPushes el predeterminado. El componente solo se revisa cuando cambia un input, ocurre un evento en su template o cambia un signal que lee. Con signals, esto funciona sin que lo pienses.- Los proyectos nuevos nacen sin zone.js. Angular ya no necesita interceptar cada
setTimeouty cada promesa para saber que algo cambió: los signals le avisan.
Eso también explica el error más molesto al migrar: un estado guardado en una propiedad común, cambiado dentro de un setTimeout, puede no aparecer en pantalla. La solución es guardarlo en un signal.
Errores comunes#
- Olvidar los paréntesis.
{{ count }}muestra la función, no el valor. Es{{ count() }}. - Modificar en el lugar.
items().push(x)no avisa a nadie, y la prueba lo confirma: elcomputedque depende de la lista sigue con el tamaño viejo. Usaitems.update((list) => [...list, x]). - Un
effectpara sincronizar estado. Si solo haceotro.set(...), es uncomputedo unlinkedSignal. - Leer un signal después de un
await. Dentro decomputedyeffect, solo cuenta como dependencia lo que se leyó de forma síncrona. Lo que viene después de unawaitno se rastrea. - Olvidar el momento de carga. Un valor derivado de un resource pasa por el estado de carga, cuando
value()vuelve al predeterminado. - Cambiar todo RxJS por signals. Debounce, cancelación y combinación de flujos siguen siendo trabajo de RxJS.
Checklist#
- Estado en
signal, derivados encomputed, efectos externos eneffect. - Ningún
effectque solo copie un valor a otro signal. - Arrays y objetos siempre reemplazados por nuevos, con
update. - Datos del servidor con
httpResourceorxResource, tratandoisLoading()yerror(). linkedSignalpara una elección del usuario que depende de una lista.- Inputs con
input()einput.required(), eventos conoutput(), doble sentido conmodel(). - RxJS solo donde hay un flujo en el tiempo, conectado con
toSignalytoObservable. - Formularios nuevos con Signal Forms.
Referencias#
Comentarios
Para comentar, entra con tu cuenta de GitHub.
Sigue leyendo

Front-end8 min de lectura
camelCase, PascalCase, kebab-case y snake_case: cuándo usar

Front-end12 min de lectura
Smart y dumb components en Angular y React, en 2026

Front-end11 min de lectura
Storybook: cómo empezar y hasta dónde vale la pena ir