Tous les articles

Front-end11 min de lecture

Signals dans Angular 22 : signal, computed, effect et plus

Guide pratique des signals dans Angular 22 : signal, computed, effect, linkedSignal, httpResource, Signal Forms, RxJS et les erreurs fréquentes, avec du code testé.

Aussi en Português, English, Español

Les signals sont arrivés dans Angular 16 comme une nouveauté et, dans Angular 22, ils sont devenus la base de presque tout : inputs, requêtes sur le template, appels HTTP, formulaires et la détection de changements elle-même. Si vous écrivez encore de l'Angular avec seulement @Input, BehaviorSubject et le pipe async, vous utilisez un framework qui a déjà changé en dessous.

Cet article va des bases jusqu'à ce qui vient de devenir stable : signal, computed, effect, linkedSignal, httpResource, les signals dans les composants, le pont avec RxJS et les Signal Forms. À la fin, les erreurs les plus fréquentes.

Une précision honnête : tout le code a été compilé avec Angular 22.3, et chaque comportement affirmé dans le texte a un test qui passe, y compris un piège que je n'ai découvert que parce que le test a échoué.

TL;DR#

  • signal contient un état. On le lit en l'appelant (count()), on le modifie avec set ou update.
  • computed dérive une valeur d'autres signals. Il est paresseux, garde le résultat en cache et ne peut pas être modifié.
  • effect sert aux effets de bord : enregistrer dans le localStorage, appeler une bibliothèque externe. Jamais pour modifier un autre signal.
  • linkedSignal est une valeur dérivée que vous pouvez aussi modifier, et qui revient à la valeur calculée quand sa source change.
  • httpResource récupère des données et relance la requête tout seul quand les signals qu'il lit changent.
  • Dans Angular 22, httpResource, rxResource et les Signal Forms sont des API stables, et OnPush est la valeur par défaut.
  • Ne modifiez jamais un objet ou un tableau sur place. items().push(x) ne prévient personne. Utilisez update avec un nouveau tableau.

Pourquoi les signals#

Avant, Angular découvrait ce qui avait changé en lançant la détection de changements sur tout l'arbre, avec l'aide de zone.js. Un signal inverse la logique : il sait qui dépend de lui. Quand il change, il prévient seulement ces dépendants, et Angular met à jour seulement cette partie de l'écran.

En pratique, cela apporte trois choses :

  • Moins de travail à l'écran, car Angular n'a pas besoin de vérifier les composants qui ne dépendent pas de ce qui a changé.
  • Un code plus prévisible, car une valeur dérivée se recalcule toute seule et n'est jamais périmée.
  • Moins de RxJS pour les choses simples. L'état de l'écran devient un signal. RxJS reste excellent pour les flux d'événements dans le temps.

signal : l'état#

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

Dans le template, la lecture est la même : {{ count() }}. Oublier les parenthèses est l'erreur numéro un des débutants.

computed : la valeur dérivée#

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

Trois choses que le test confirme :

  • Il est paresseux. La fonction ne s'exécute que quand quelqu'un lit total(). Créer le computed n'exécute rien.
  • Il garde le résultat. Lire total() deux fois de suite ne fait le calcul qu'une fois.
  • Il ne recalcule que quand une dépendance change. Et il trouve ses dépendances tout seul, à partir des signals qu'il a lus.

Et il n'y a pas de set : une valeur dérivée ne se modifie pas à la main. Si vous avez envie de modifier un computed, vous voulez probablement un linkedSignal (plus bas).

effect : l'effet de bord#

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

Un effect s'exécute une fois puis à nouveau chaque fois qu'un signal qu'il a lu change. Il sert à parler au monde extérieur à Angular : le localStorage, un graphique dessiné par une bibliothèque, un log.

Le mauvais usage le plus fréquent est celui-ci :

// 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 l'effect ne fait que copier ou calculer une valeur pour la mettre dans un autre signal, remplacez-le par computed ou linkedSignal. Le résultat est le même, sans cycle supplémentaire et sans risque de désordre.

untracked : lire sans dépendre#

Parfois, vous voulez lire un signal dans un effect sans qu'il déclenche l'effect :

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

Ici, modifier query relance l'effet. Modifier page ne le relance pas, mais quand l'effet s'exécute, il lit la valeur actuelle de page.

linkedSignal : une valeur dérivée modifiable#

Le cas classique : une liste d'options et l'option choisie. Le choix appartient à l'utilisateur, mais si la liste change, le choix doit revenir à une valeur qui a du sens.

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

Il accepte aussi une forme plus complète, avec accès à la valeur précédente, qui apparaît dans l'exemple de la section suivante.

httpResource : des données qui se chargent toutes seules#

En réunissant tout dans un composant de recherche de produits :

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

Ce qui se passe ici :

  • query est l'état : le texte saisi.
  • httpResource lit query() et, à chaque changement, relance la requête. Si la fonction renvoie undefined, il ne fait aucune requête : c'est ainsi que la recherche attend au moins deux lettres. Il expose value(), isLoading() et error() sous forme de signals.
  • count est un simple computed sur le résultat.
  • selected est un linkedSignal avec accès à la valeur précédente : l'utilisateur choisit un produit, et quand une nouvelle liste arrive, le choix n'est conservé que si le même produit y figure encore.
  • L'effect enregistre la dernière recherche dans le localStorage, qui se trouve en dehors d'Angular.
Chaque valeur sait de quoi elle dépend. Quand query change, seul ce qui en dépend bouge

Le piège que le test a révélé#

Dans la première version, le linkedSignal utilisait directement products.value() comme source, et la sélection disparaissait chaque fois que l'utilisateur affinait sa recherche, même si le produit figurait encore dans la nouvelle liste.

La raison : pendant que httpResource relance la requête, value() revient au defaultValue, la liste vide. Le linkedSignal voyait la liste vide, ne trouvait pas le produit et effaçait le choix. Quand les résultats arrivaient, la valeur précédente était déjà null.

La correction est dans le code ci-dessus : tant que isLoading() est vrai, la source devient null, et la fonction garde la valeur précédente. Cela vaut pour toute valeur dérivée d'une resource : souvenez-vous que ce moment intermédiaire existe.

Les signals dans les composants#

Les API des composants sont aussi des signals maintenant :

AvantMaintenantCe que c'est
@Input() namename = input<string>()entrée du composant, lue avec name()
@Input({ required: true })input.required<string>()entrée obligatoire, erreur au build si elle manque
@Output() + EventEmitteroutput<string>()événement (pas un signal, mais même style)
@Input + @Output xChangemodel<string>()valeur dans les deux sens avec [(x)]
@ViewChild('ref')viewChild<ElementRef>('ref')requête sur le template, lue comme un signal

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

Comme input() est un signal, on peut l'utiliser dans un computed, et le composant réagit tout seul quand le parent change la valeur. Plus besoin de ngOnChanges pour ça.

Signals et RxJS#

Les signals ne remplacent pas RxJS. Ils couvrent l'état. RxJS reste meilleur pour les flux d'événements dans le temps : debounce, annulation de la requête précédente, combinaison de sources. Le pont, c'est le paquet @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 transforme un Observable en signal. Ici, l'événement resize de la fenêtre devient une valeur que le template lit.
  • toObservable fait le chemin inverse, pour appliquer debounceTime à un signal.
  • rxResource est une resource dont le chargement renvoie un Observable. Stable depuis Angular 22.

Signal Forms#

Depuis Angular 22, les formulaires ont aussi une version à base de signals, et c'est une API stable. Le modèle est un signal ordinaire, et le formulaire lit et écrit directement dedans :

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(modèle, règles) crée un arbre de champs qui a la même forme que le modèle.
  • Les règles (required, email, minLength) vivent dans une fonction, loin du template.
  • [formField] relie chaque champ à un <input>, dans les deux sens.
  • L'état de chaque champ est un signal : signUpForm.email().errors(), signUpForm().valid().

Les Reactive Forms fonctionnent toujours. Pour un nouveau formulaire, les Signal Forms sont plus courts et dialoguent directement avec le reste du code en signals.

Et OnPush et zone.js ?#

Deux conséquences directes de tout cela dans Angular 22 :

  • OnPush est la valeur par défaut. Un composant n'est vérifié que quand un input change, qu'un événement se produit dans son template ou qu'un signal qu'il lit change. Avec les signals, cela fonctionne sans y penser.
  • Les nouveaux projets démarrent sans zone.js. Angular n'a plus besoin d'intercepter chaque setTimeout et chaque promesse pour savoir que quelque chose a changé : les signals le préviennent.

Cela explique aussi l'erreur la plus agaçante lors d'une migration : un état gardé dans une propriété ordinaire, modifié dans un setTimeout, peut ne pas apparaître à l'écran. La solution est de le garder dans un signal.

Erreurs fréquentes#

  • Oublier les parenthèses. {{ count }} affiche la fonction, pas la valeur. C'est {{ count() }}.
  • Modifier sur place. items().push(x) ne prévient personne, et le test le confirme : le computed qui dépend de la liste garde l'ancienne longueur. Utilisez items.update((list) => [...list, x]).
  • Un effect pour synchroniser un état. S'il ne fait que autre.set(...), c'est un computed ou un linkedSignal.
  • Lire un signal après un await. Dans computed et effect, seul ce qui est lu de façon synchrone compte comme dépendance. Ce qui vient après un await n'est pas suivi.
  • Oublier le moment du chargement. Une valeur dérivée d'une resource passe par l'état de chargement, quand value() revient à la valeur par défaut.
  • Remplacer tout RxJS par des signals. Debounce, annulation et combinaison de flux restent le travail de RxJS.

Checklist#

  • État dans signal, valeurs dérivées dans computed, effets externes dans effect.
  • Aucun effect qui ne fait que copier une valeur dans un autre signal.
  • Tableaux et objets toujours remplacés par de nouveaux, avec update.
  • Données du serveur avec httpResource ou rxResource, en gérant isLoading() et error().
  • linkedSignal pour un choix de l'utilisateur qui dépend d'une liste.
  • Inputs avec input() et input.required(), événements avec output(), double sens avec model().
  • RxJS seulement là où il y a un flux dans le temps, relié par toSignal et toObservable.
  • Nouveaux formulaires avec les Signal Forms.

Références#

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

Écrit par

Ingénieure logiciel et designer. J'écris sur ce que je rencontre en créant des apps, des APIs et des produits.

Commentaires

Connectez-vous avec votre compte GitHub pour commenter.