Accueil › Angular › Les observables : ce qu'il faut comprendre
Les observables : ce qu'il faut comprendre
RxJS avec Angularintermediaire
Un observable représente un flux de valeurs dans le temps. Contrairement à une Promise, il est paresseux : rien ne s'exécute avant subscribe().
import { of, fromEvent, interval } from 'rxjs';
const nombres$ = of(1, 2, 3); // émet 3 valeurs puis se termine
const clics$ = fromEvent(bouton, 'click'); // émet à chaque clic, ne se termine jamais
const minuteur$ = interval(1000); // émet 0, 1, 2… toutes les secondes
nombres$.subscribe(n => console.log(n));
La plupart des observables créés dans une application sont froids : chaque subscribe() relance l'exécution depuis le début, indépendamment des autres. Deux abonnements à un même http.get(...) déclenchent deux requêtes distinctes.
subscribe() renvoie une Subscription, à désabonner avec unsubscribe() quand le flux ne se termine pas de lui-même (interval, fromEvent, WebSocket) — sinon la fonction continue à s'exécuter après que le composant qui l'a lancée a disparu. Deux solutions courantes en Angular 21 :
import { DestroyRef, inject } from '@angular/core';
import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
export class SuiviStock {
private destroyRef = inject(DestroyRef);
constructor() {
interval(5000)
.pipe(takeUntilDestroyed(this.destroyRef))
.subscribe(() => this.rafraichirStock());
}
}
Dans un template, AsyncPipe (| async) gère l'abonnement et le désabonnement automatiquement — pas de subscribe() manuel à écrire pour un simple affichage.
Malgré la montée des signaux, RxJS reste indispensable pour tout ce qu'un signal ne modélise pas naturellement : des événements répétés, un flux continu (WebSocket, minuteur), et surtout l'annulation/la composition temporelle (attendre, ignorer les émissions intermédiaires, combiner plusieurs sources).
Les termes à connaître
- Observable
Représente un flux de valeurs dans le temps (zéro, une ou plusieurs), produit par RxJS. Contrairement à une valeur classique, un observable ne « fait » rien tant que personne ne s'y abonne.
- subscribe()
Démarre l'exécution d'un observable en lui attachant un Observer (des callbacks
next,error,complete). C'est le seul moment où le code producteur (requête HTTP, minuteur, écouteur d'événement…) s'exécute réellement.- Subscription
Objet renvoyé par
subscribe(), représentant l'abonnement actif. Sa méthodeunsubscribe()arrête l'écoute et libère les ressources associées (annule une requête en cours, retire un écouteur d'événement, stoppe un minuteur).- Observable froid (cold)
Un observable qui ne produit rien avant qu'on ne s'y abonne, et qui rejoue son exécution indépendamment pour chaque abonné (deux
subscribe()sur un observable HTTP froid déclenchent deux requêtes distinctes). La grande majorité des observables créés dans une application Angular sont froids.- takeUntilDestroyed()
Opérateur (
@angular/core/rxjs-interop) qui désabonne automatiquement un observable quand le contexte d'injection courant (composant, directive, service) est détruit. Évite d'écrire et de stocker soi-même uneSubscriptionà nettoyer dansngOnDestroy.- DestroyRef
Jeton injectable (
@angular/core) représentant le cycle de vie du contexte courant.takeUntilDestroyed()s'appuie dessus par défaut ; on peut aussi l'utiliser directement avecdestroyRef.onDestroy(() => ...)pour du nettoyage personnalisé.- AsyncPipe
Pipe de template (
| async) qui s'abonne à un observable (ou une Promise) à l'affichage du composant et se désabonne automatiquement à sa destruction. Évite tout appel manuel àsubscribe()/unsubscribe()pour un simple affichage.
Cette page présente la partie essentielle de la leçon. Les exemples commentés, les pièges courants et les trois questions de quiz sont dans l'application.