À quelle structure de données en JavaScript l'objet…

La structure de données Observable à froid (du anglais Cold Observable), qui est un concept de la programmation réactive (par exemple, dans la bibliothèque RxJS).

Principaux points communs:

Nature paresseuse: L'Observable commence à émettre des valeurs uniquement lorsqu'il y a un abonné. Sans abonnement, l'Observable n'est pas actif.
Multiples abonnés, flux indépendants: Chaque nouvel abonné reçoit l'ensemble complet des valeurs depuis le début, indépendamment des autres abonnés. Cela crée des flux de données indépendants pour chaque abonné.

Exemple de structure d'un observable à froid (conceptuellement):

// Imaginez que c'est un "générateur" de valeurs
function generateValues() {
  let i = 0;
  return {
    // Méthode qui retourne la prochaine valeur (lorsqu'elle est demandée)
    next: function() {
      return { value: i++, done: false };
    }
  };
}

// "Observable" - en fait, simplement une fonction qui accepte un abonné
function coldObservableExample(subscriber) {
  const generator = generateValues();

  // Simulation d'émission de valeurs
  setTimeout(() => {
    subscriber.next(generator.next().value);
  }, 100);

  setTimeout(() => {
    subscriber.next(generator.next().value);
  }, 200);

  setTimeout(() => {
    subscriber.complete(); // Fin du flux
  }, 300);

  // Retourne un objet d'abonnement (pour se désabonner)
  return {
    unsubscribe: () => {
      console.log('Désabonnement');
      // Ici, la logique pour arrêter le générateur/les temporisateurs
    }
  };
}

// Abonné 1
const subscription1 = coldObservableExample({
  next: (value) => console.log('Abonné 1 a reçu:', value),
  error: (err) => console.error('Erreur 1:', err),
  complete: () => console.log('Abonné 1 terminé')
});

// Abonné 2 (commencera à recevoir les valeurs depuis le début)
setTimeout(() => {
  const subscription2 = coldObservableExample({
    next: (value) => console.log('Abonné 2 a reçu:', value),
    error: (err) => console.error('Erreur 2:', err),
    complete: () => console.log('Abonné 2 terminé')
  });
}, 150);

// Désabonnement du premier abonné
setTimeout(() => {
  subscription1.unsubscribe();
}, 250);

Contrairement à l'Observable chaud (Hot Observable), qui commence à émettre des valeurs immédiatement, indépendamment des abonnés, et tous les abonnés reçoivent les valeurs depuis le moment de leur abonnement, l'Observable à froid conserve et reproduit le flux complet de données pour chaque nouvel abonné. Cette caractéristique le rapproche de la conception de Observable en JavaScript (dans le contexte de RxJS et bibliothèques similaires).

Comparaison (simplifiée):

Caractéristique	Observable à froid	Observable chaud
Début d'émission	Lors de l'abonnement	Immédiatement
Flux pour les abonnés	Flux complet pour chacun	Valeurs depuis le moment de l'abonnement
Utilisation	Requêtes HTTP, lecture de fichiers, itération	Événements DOM, websockets, temporisateurs

À quelle structure de données en JavaScript l'objet Observable est-il proche?