Do jakiej struktury danych w JavaScript jest podobny…

Struktura danych Cold Observable (z ang. Cold Observable), będąca koncepcją programowania reaktywnego (np. w bibliotece RxJS).

Kluczowe podobieństwa:

Pogodna natura: Observable zaczyna emitować wartości tylko wtedy, gdy jest subskrybowany. Bez subskrypcji, Observable nie jest aktywny.
Wiele subskrybentów, niezależne strumienie: Każdy nowy subskrybent otrzymuje pełny zestaw wartości od początku, niezależnie od innych subskrybentów. Tworzy to niezależne strumienie danych dla każdego subskrybenta.

Przykład struktury Cold Observable (konceptualnie):

// Wyobraź sobie, że to "generator" wartości
function generateValues() {
  let i = 0;
  return {
    // Metoda zwracająca następną wartość (po jej żądaniu)
    next: function() {
      return { value: i++, done: false };
    }
  };
}

// "Observable" - w istocie, po prostu funkcja przyjmująca subskrybenta
function coldObservableExample(subscriber) {
  const generator = generateValues();

  // Emulacja emisji wartości
  setTimeout(() => {
    subscriber.next(generator.next().value);
  }, 100);

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

  setTimeout(() => {
    subscriber.complete(); // Zakończenie strumienia
  }, 300);

  // Zwracamy obiekt subskrypcji (do odsubskrybowania)
  return {
    unsubscribe: () => {
      console.log('Odsubskrybowanie');
      // Tu mogłaby być logika zatrzymania generatora/timerów
    }
  };
}

// Subskrybent 1
const subscription1 = coldObservableExample({
  next: (value) => console.log('Subskrybent 1 otrzymał:', value),
  error: (err) => console.error('Błąd 1:', err),
  complete: () => console.log('Subskrybent 1 zakończony')
});

// Subskrybent 2 (zacznie otrzymywać wartości od początku)
setTimeout(() => {
  const subscription2 = coldObservableExample({
    next: (value) => console.log('Subskrybent 2 otrzymał:', value),
    error: (err) => console.error('Błąd 2:', err),
    complete: () => console.log('Subskrybent 2 zakończony')
  });
}, 150);

// Odsubskrybowanie pierwszego subskrybenta
setTimeout(() => {
  subscription1.unsubscribe();
}, 250);

W przeciwieństwie do Hot Observable, które zaczyna emitować wartości natychmiast, niezależnie od subskrybentów, i wszyscy subskrybenci otrzymują wartości od momentu subskrypcji, Cold Observable przechowuje i odtwarza pełny strumień danych dla każdego nowego subskrybenta. Ta cecha zbliża go do koncepcji Observable w JavaScript (w kontekście RxJS i podobnych bibliotek).

Porównanie (uproszczone):

Cecha	Cold Observable	Hot Observable
Początek emisji	Przy subskrypcji	Natychmiast
Strumień dla subskrybentów	Pełny strumień dla każdego	Wartości od momentu subskrypcji
Użycie	Żądania HTTP, czytanie plików, iteracja	Wydarzenia DOM, web-sockety, timery

Do jakiej struktury danych w JavaScript jest podobny obiekt Observable?