Todos los artículos

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.

También en Português, English, Français

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#

  • signal guarda estado. Se lee llamándolo (count()), se cambia con set o update.
  • computed deriva un valor de otros signals. Es perezoso, guarda el resultado y no se puede modificar.
  • effect es para efectos secundarios: guardar en localStorage, llamar a una biblioteca externa. Nunca para cambiar otro signal.
  • linkedSignal es un derivado que también puedes modificar, y que vuelve al valor calculado cuando cambia su origen.
  • httpResource busca datos y vuelve a buscar solo cuando cambian los signals que lee.
  • En Angular 22, httpResource, rxResource y los Signal Forms son API estable, y OnPush es el predeterminado.
  • Nunca modifiques un objeto o un array en el lugar. items().push(x) no avisa a nadie. Usa update con 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: 6

En 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();          // 30

Tres cosas que la prueba confirma:

  • Es perezoso. La función solo corre cuando alguien lee total(). Crear el computed no 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 value

Tambié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:

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()));
  }
}

Qué pasa aquí:

  • query es el estado: el texto escrito.
  • httpResource lee query() y, en cada cambio, vuelve a hacer la petición. Si la función devuelve undefined, no hace ninguna petición: así la búsqueda espera tener al menos dos letras. Expone value(), isLoading() y error() como signals.
  • count es un computed simple sobre el resultado.
  • selected es un linkedSignal con 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 effect guarda la última búsqueda en localStorage, que está fuera de Angular.
Cada valor sabe de qué depende. Cambia query y solo se mueve lo que depende de él

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:

AntesAhoraQué es
@Input() namename = input<string>()entrada del componente, se lee con name()
@Input({ required: true })input.required<string>()entrada obligatoria, error en el build si falta
@Output() + EventEmitteroutput<string>()evento (no es signal, pero sigue el mismo estilo)
@Input + @Output xChangemodel<string>()valor en los dos sentidos con [(x)]
@ViewChild('ref')viewChild<ElementRef>('ref')consulta al template, se lee como signal

Un ejemplo 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() 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:

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 convierte un Observable en signal. Aquí, el evento resize de la ventana pasa a ser un valor que el template lee.
  • toObservable hace el camino inverso, para aplicar debounceTime a un signal.
  • rxResource es 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:

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

  • OnPush es 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 setTimeout y 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: el computed que depende de la lista sigue con el tamaño viejo. Usa items.update((list) => [...list, x]).
  • Un effect para sincronizar estado. Si solo hace otro.set(...), es un computed o un linkedSignal.
  • Leer un signal después de un await. Dentro de computed y effect, solo cuenta como dependencia lo que se leyó de forma síncrona. Lo que viene después de un await no 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 en computed, efectos externos en effect.
  • Ningún effect que solo copie un valor a otro signal.
  • Arrays y objetos siempre reemplazados por nuevos, con update.
  • Datos del servidor con httpResource o rxResource, tratando isLoading() y error().
  • linkedSignal para una elección del usuario que depende de una lista.
  • Inputs con input() e input.required(), eventos con output(), doble sentido con model().
  • RxJS solo donde hay un flujo en el tiempo, conectado con toSignal y toObservable.
  • Formularios nuevos con Signal Forms.

Referencias#

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

Escrito por

Ingeniera de software y diseñadora. Escribo sobre lo que encuentro construyendo apps, APIs y productos.

Comentarios

Para comentar, entra con tu cuenta de GitHub.