Welche Datenstruktur in JavaScript ist dem…

Die Datenstruktur Cold Observable (vom Englischen Cold Observable), die ein Konzept aus der reaktiven Programmierung ist (zum Beispiel in der RxJS-Bibliothek).

Wichtige Gemeinsamkeiten:

Träge Natur: Ein Observable beginnt, Werte zu emittieren, nur wenn ein Abonnent vorhanden ist. Ohne Abonnement ist das Observable nicht aktiv.
Mehrere Abonnenten, unabhängige Ströme: Jeder neue Abonnent erhält den vollständigen Wertebereich von Anfang an, unabhängig von anderen Abonnenten. Dies schafft unabhängige Datenströme für jeden Abonnenten.

Beispiel für eine Cold Observable-Struktur (konzeptuell):

// Stellen Sie sich vor, dies ist ein "Generator" von Werten
function generateValues() {
  let i = 0;
  return {
    // Methode, die den nächsten Wert zurückgibt (bei Anfrage)
    next: function() {
      return { value: i++, done: false };
    }
  };
}

// "Observable" - im Wesentlichen nur eine Funktion, die einen Abonnenten akzeptiert
function coldObservableExample(subscriber) {
  const generator = generateValues();

  // Emulation der Wertemission
  setTimeout(() => {
    subscriber.next(generator.next().value);
  }, 100);

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

  setTimeout(() => {
    subscriber.complete(); // Abschluss des Flusses
  }, 300);

  // Gibt ein Abonnement-Objekt zurück (zum Abbestellen)
  return {
    unsubscribe: () => {
      console.log('Abbestellen');
      // Hier könnte die Logik zum Beenden des Generators/Timers sein
    }
  };
}

// Abonnent 1
const subscription1 = coldObservableExample({
  next: (value) => console.log('Abonnent 1 erhielt:', value),
  error: (err) => console.error('Fehler 1:', err),
  complete: () => console.log('Abonnent 1 beendet')
});

// Abonnent 2 (beginnt, Werte ab dem Anfang zu erhalten)
setTimeout(() => {
  const subscription2 = coldObservableExample({
    next: (value) => console.log('Abonnent 2 erhielt:', value),
    error: (err) => console.error('Fehler 2:', err),
    complete: () => console.log('Abonnent 2 beendet')
  });
}, 150);

// Abmeldung des ersten Abonnenten
setTimeout(() => {
  subscription1.unsubscribe();
}, 250);

Im Gegensatz zum Hot Observable, das sofort Werte emittiert, unabhängig von den Abonnenten, und alle Abonnenten die Werte ab dem Zeitpunkt der Anmeldung erhalten, speichert und reproduziert das Cold Observable den vollständigen Datenstrom für jeden neuen Abonnenten. Diese Eigenschaft bringt es näher an das Konzept des Observable in JavaScript (im Kontext von RxJS und ähnlichen Bibliotheken).

Vergleich (vereinfachend):

Eigenschaft	Cold Observable	Hot Observable
Beginn der Emission	Bei Anmeldung	Sofort
Datenstrom für Abonnenten	Vollständiger Datenstrom für jeden	Werte ab dem Zeitpunkt der Anmeldung
Verwendung	HTTP-Anfragen, Dateilesen, Iteration	DOM-Ereignisse, WebSockets, Timer

Welche Datenstruktur in JavaScript ist dem Observable-Objekt ähnlich?