Formations — 1 037 leçons en français

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éthode unsubscribe() 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 une Subscription à nettoyer dans ngOnDestroy.

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 avec destroyRef.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.

Lire l'explication détaillée et faire le quiz →

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.