Hace dos años escribí que Signals había llegado para quedarse. Hoy ya no es una apuesta: desde Angular 21 las aplicaciones nuevas son zoneless por defecto y, con Angular 22 (junio de 2026), OnPush pasó a ser la estrategia de detección de cambios por defecto, Signal Forms dejó de ser experimental y resource(), rxResource() y httpResource() son estables. El modelo mental de Angular cambió, y conviene entender cómo encajan las piezas antes de migrar a ciegas.
Qué significa “zoneless” en la práctica
Zone.js interceptaba cada evento asíncrono del navegador (timers, promesas, eventos del DOM) para avisarle a Angular que “algo pudo cambiar”. Funcionaba, pero tenía un costo: detección de cambios disparada por cosas que no tocaban la UI y un archivo extra en el bundle.
Sin Zone.js, Angular sabe que debe actualizar la vista cuando:
- cambia un signal que se lee en una plantilla,
- ocurre un evento enlazado en la plantilla (
(click),(input)…), - se llama explícitamente a
markForCheck(), - termina una petición o una tarea que actualiza un signal.
En apps nuevas no tienes que hacer nada. En apps existentes que dependen de Zone.js, Angular 21 en adelante te pide declararlo de forma explícita con provideZoneChangeDetection(). Esa línea es tu mapa de deuda: mientras exista, todavía hay código que depende de la “magia”.
Mi orden de migración en proyectos enterprise
En aplicaciones grandes no migro todo de golpe. El orden que mejor me ha funcionado:
- Componentes hoja primero: botones, chips, tarjetas. Pasan a
input(),output()ycomputed()sin tocar servicios. - Estado local a signals: todo lo que era una propiedad mutada en el componente se vuelve
signal(). - Lecturas HTTP a
httpResource(): elimina suscripciones manuales y estados de carga duplicados. - Formularios críticos a Signal Forms: empezando por los más simples para que el equipo aprenda el patrón.
- Quitar
provideZoneChangeDetection()cuando las pruebas de punta a punta pasan sin él.
Angular trae una migración automática para el cambio de OnPush por defecto (los componentes que dependían del comportamiento anterior quedan marcados como Eager), y el servidor MCP del CLI incluye una guía paso a paso para la transición a OnPush + zoneless.
Estado derivado: computed y linkedSignal
El error más común que veo es usar effect() para sincronizar estado. Si un valor se puede calcular a partir de otro, es un computed():
import { Component, computed, input, signal } from '@angular/core';
@Component({
selector: 'app-cart-summary',
template: `
<p>{{ items().length }} productos · {{ total() | currency }}</p>
`,
})
export class CartSummary {
readonly items = input.required<CartItem[]>();
readonly discount = signal(0);
readonly total = computed(() => {
const subtotal = this.items().reduce((acc, i) => acc + i.price * i.qty, 0);
return subtotal * (1 - this.discount());
});
}
Cuando necesito un valor que se deriva de otro pero que el usuario también puede editar (por ejemplo, la opción seleccionada que se reinicia al cambiar la lista), uso linkedSignal(). effect() lo reservo para lo que realmente sale de Angular: analítica, localStorage, integraciones con librerías de terceros.
Datos remotos con httpResource
Antes, cada pantalla tenía su propia combinación de loading, error, subscribe y takeUntil. Con httpResource() la petición se vuelve una función reactiva de sus parámetros:
import { Component, input } from '@angular/core';
import { httpResource } from '@angular/common/http';
@Component({
selector: 'app-order-detail',
template: `
@if (order.isLoading()) {
<app-skeleton />
} @else if (order.error()) {
<app-error (retry)="order.reload()" />
} @else if (order.hasValue()) {
<app-order-card [order]="order.value()" />
}
`,
})
export class OrderDetail {
readonly id = input.required<string>();
readonly order = httpResource<Order>(() => `/api/orders/${this.id()}`);
}
Si id cambia, la petición anterior se cancela y sale una nueva. Sin switchMap, sin fugas de suscripciones. RxJS sigue siendo mi herramienta para flujos de eventos complejos (websockets, debounce de búsquedas, combinaciones de streams), y rxResource() es el puente cuando la fuente ya es un Observable.
Algo que conviene saber al actualizar: en Angular 22 el cliente HTTP usa la Fetch API por debajo, así que withFetch() ya es el comportamiento por defecto.
Signal Forms: formularios tipados de verdad
Los formularios enterprise son donde más tiempo se pierde. Signal Forms parte de un modelo (un signal) y un esquema de validación:
import { Component, signal } from '@angular/core';
import { form, FormField, FormRoot, required, email } from '@angular/forms/signals';
@Component({
selector: 'app-contact',
imports: [FormField, FormRoot],
template: `
<form [formRoot]="contactForm">
<input [formField]="contactForm.name" />
<input type="email" [formField]="contactForm.email" />
<button type="submit" [disabled]="contactForm().submitting()">Enviar</button>
</form>
`,
})
export class Contact {
readonly model = signal({ name: '', email: '' });
readonly contactForm = form(
this.model,
(path) => {
required(path.name);
required(path.email);
email(path.email);
},
{
submission: {
action: async (field) => {
const res = await saveContact(field().value());
if (res.ok) return;
return { kind: 'serverError', message: 'No se pudo enviar' };
},
},
},
);
}
Lo que más valoro: el tipo del formulario sale del modelo, la validación vive en un solo lugar y el estado (valid, touched, submitting) son signals que la plantilla lee sin suscripciones.
Lo que no cambiaría todavía
- No reescribas RxJS que funciona. Si un flujo de eventos está bien probado, déjalo y conviértelo en signal en el borde con
toSignal(). - No migres formularios gigantes primero. Empieza por uno pequeño y crea una guía interna con los patrones del equipo.
- No asumas que zoneless arregla el rendimiento. Elimina trabajo innecesario, pero un componente que recalcula listas enormes en cada cambio sigue siendo lento. Ahí el trabajo es de arquitectura.
Conclusión
Angular 22 es el Angular más coherente que he usado: signals para el estado, resources para los datos, Signal Forms para la entrada del usuario y una detección de cambios que solo trabaja cuando hay algo que actualizar. La migración se hace por capas, componente a componente, y cada paso deja la app más simple que antes.