Formations — 1 037 leçons en français

Accueil › Angular › Les opérateurs essentiels

Les opérateurs essentiels

RxJS avec Angularintermediaire

pipe() enchaîne des opérateurs : chacun reçoit le flux transformé par le précédent et renvoie un nouvel observable, sans jamais modifier l'original.

produits$.pipe(
  filter(p => p.enStock),
  map(p => p.nom),
  tap(nom => console.log('produit disponible :', nom)),
);

Pour une recherche au fil de la frappe, le trio debounceTime + distinctUntilChanged + switchMap est quasi systématique : attendre une pause dans la frappe, ignorer les termes identiques, puis lancer la requête en annulant la précédente si elle est encore en vol.

motCle$.pipe(
  debounceTime(300),
  distinctUntilChanged(),
  switchMap(terme => this.http.get<Produit[]>(`/api/produits?q=${terme}`)),
);

Pour une requête HTTP robuste : retry() pour retenter automatiquement, catchError() pour intercepter une erreur définitive et fournir un résultat de repli, finalize() pour arrêter un indicateur de chargement dans tous les cas (succès ou erreur).

combineLatest() et forkJoin() combinent plusieurs flux : le premier recombine en continu, le second attend que tout se termine pour n'émettre qu'une fois.

Le choix le plus déterminant reste celui de l'opérateur d'aplatissement — switchMap, mergeMap, concatMap ou exhaustMap — détaillé plus bas : ils se ressemblent syntaxiquement mais produisent des comportements très différents selon ce qu'on veut faire des appels en cours.

Les termes à connaître

pipe()

Méthode d'un observable qui enchaîne une suite d'opérateurs, chacun recevant le flux transformé par le précédent et renvoyant un nouvel observable. Ne modifie jamais l'observable d'origine (immuable).

map() et filter()

map() transforme chaque valeur émise (comme Array.prototype.map) ; filter() ne laisse passer que les valeurs qui satisfont un prédicat (comme Array.prototype.filter). Les deux opérateurs les plus élémentaires pour transformer un flux.

debounceTime() et distinctUntilChanged()

debounceTime(ms) attend un silence de ms millisecondes avant de laisser passer la dernière valeur (utile pour une recherche au fil de la frappe). distinctUntilChanged() ignore une valeur identique à la précédente, évitant un travail redondant.

catchError() et retry()

catchError() intercepte une erreur du flux et permet de la remplacer par un observable de repli (ou de la relancer). retry(n) réabonne automatiquement au flux source jusqu'à n fois en cas d'erreur, avant de laisser l'erreur passer.

finalize()

Exécute une fonction quand le flux se termine, que ce soit par succès (complete), par erreur, ou par désabonnement — l'équivalent d'un finally pour un observable. Utile pour arrêter un indicateur de chargement dans tous les cas.

combineLatest() et forkJoin()

combineLatest([a$, b$]) recombine la dernière valeur de chaque flux à chaque émission de l'un d'eux (tant que tous ont émis au moins une fois). forkJoin([a$, b$]) attend que tous les flux se terminent et n'émet qu'une seule fois, avec la dernière valeur de chacun.

switchMap(), mergeMap(), concatMap(), exhaustMap()

Les quatre opérateurs d'aplatissement (« flattening ») : chacun reçoit une valeur et la transforme en un nouvel observable interne, mais ils diffèrent sur ce qu'ils font des observables internes en cours quand une nouvelle valeur arrive (voir le tableau comparatif).

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.