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é.

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#
signalcontient un état. On le lit en l'appelant (count()), on le modifie avecsetouupdate.computeddérive une valeur d'autres signals. Il est paresseux, garde le résultat en cache et ne peut pas être modifié.effectsert aux effets de bord : enregistrer dans lelocalStorage, appeler une bibliothèque externe. Jamais pour modifier un autre signal.linkedSignalest une valeur dérivée que vous pouvez aussi modifier, et qui revient à la valeur calculée quand sa source change.httpResourcerécupère des données et relance la requête tout seul quand les signals qu'il lit changent.- Dans Angular 22,
httpResource,rxResourceet les Signal Forms sont des API stables, etOnPushest la valeur par défaut. - Ne modifiez jamais un objet ou un tableau sur place.
items().push(x)ne prévient personne. Utilisezupdateavec 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: 6Dans 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(); // 30Trois choses que le test confirme :
- Il est paresseux. La fonction ne s'exécute que quand quelqu'un lit
total(). Créer lecomputedn'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 valueIl 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 :
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 :
queryest l'état : le texte saisi.httpResourcelitquery()et, à chaque changement, relance la requête. Si la fonction renvoieundefined, il ne fait aucune requête : c'est ainsi que la recherche attend au moins deux lettres. Il exposevalue(),isLoading()eterror()sous forme de signals.countest un simplecomputedsur le résultat.selectedest unlinkedSignalavec 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'
effectenregistre la dernière recherche dans lelocalStorage, qui se trouve en dehors d'Angular.
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 :
| Avant | Maintenant | Ce que c'est |
|---|---|---|
@Input() name | name = 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() + EventEmitter | output<string>() | événement (pas un signal, mais même style) |
@Input + @Output xChange | model<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 :
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 :
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 } }),
});
}toSignaltransforme un Observable en signal. Ici, l'événementresizede la fenêtre devient une valeur que le template lit.toObservablefait le chemin inverse, pour appliquerdebounceTimeà un signal.rxResourceest 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 :
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 :
OnPushest 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
setTimeoutet 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 : lecomputedqui dépend de la liste garde l'ancienne longueur. Utilisezitems.update((list) => [...list, x]). - Un
effectpour synchroniser un état. S'il ne fait queautre.set(...), c'est uncomputedou unlinkedSignal. - Lire un signal après un
await. Danscomputedeteffect, seul ce qui est lu de façon synchrone compte comme dépendance. Ce qui vient après unawaitn'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 danscomputed, effets externes danseffect. - Aucun
effectqui 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
httpResourceourxResource, en gérantisLoading()eterror(). linkedSignalpour un choix de l'utilisateur qui dépend d'une liste.- Inputs avec
input()etinput.required(), événements avecoutput(), double sens avecmodel(). - RxJS seulement là où il y a un flux dans le temps, relié par
toSignalettoObservable. - Nouveaux formulaires avec les Signal Forms.
Références#
Commentaires
Connectez-vous avec votre compte GitHub pour commenter.
À lire aussi

Front-end9 min de lecture
camelCase, PascalCase, kebab-case et snake_case : quand ?

Front-end12 min de lecture
Composants smart et dumb en Angular et React, en 2026

Front-end11 min de lecture
Storybook : comment démarrer et jusqu'où aller