Qu'est-ce qu'un observable?

Observable est une entité représentant un flux de données ou d’événements, qui peut être asynchrone. Les sources observables peuvent émettre des valeurs sur une période donnée, et les abonnés (Subscribers ou Observers) peuvent réagir à ces valeurs à mesure qu’elles apparaissent.

Concepts clés:

• Observable (Source observable) : Source de données ou d’événements.
• Observer (Observateur) : Objet avec des méthodes pour réagir aux événements de l’Observable (next, error, complete).
  • next : Recevoir la valeur suivante.
  • error : Survenue d’une erreur.
  • complete : Fin du flux de données.
• Subscription (Abonnement) : Connexion entre l’Observable et l’Observer. L’abonnement est créé lors de l’appel de la méthode subscribe sur un Observable. Il permet à l’Observer de recevoir des valeurs et de gérer le cycle de vie de l’abonnement (par exemple, se désabonner pour éviter les fuites de mémoire).
• Operators (Opérateurs) : Fonctions pour transformer, combiner et gérer les flux d’Observable. Exemples : map, filter, mergeMap, debounceTime.

Contrairement aux Promises, les Observable peuvent émettre plusieurs valeurs au fil du temps, représentant des flux de données plutôt qu’un événement asynchrone unique.

Exemple d’utilisation en RxJS (une bibliothèque populaire pour la programmation réactive):

import { Observable } from 'rxjs';
import { map } from 'rxjs/operators';

// Création d’un Observable à partir d’un tableau
const source = new Observable(observer => {
  observer.next(1);
  observer.next(2);
  observer.next(3);
  observer.complete(); // Fin du flux
});

// Abonnement et utilisation de l’opérateur
const subscription = source.pipe(
  map(value => value * 2) // L’opérateur map double chaque valeur
).subscribe({
  next: value => console.log(value), // Réception des valeurs : 2, 4, 6
  error: err => console.error(err), // Gestion des erreurs
  complete: () => console.log('Complete!') // Fin
});

Principaux avantages:

• Programmation réactive : gestion pratique des flux de données asynchrones.
• Composabilité : possibilité de combiner et transformer facilement les flux avec des opérateurs.
• Gestion du cycle de vie : l’abonnement permet de gérer explicitement la réception des données et d’éviter les fuites de mémoire.