S jakou datovou strukturou je si podobný objekt…

Datová struktura studeného Observable (anglicky Cold Observable), což je koncept z reaktivního programování (například v knihovně RxJS).

Hlavní podobnosti:

Líná povaha: Observable začíná emitovat hodnoty až při existenci odběratele (subscriber). Bez odběratele není Observable aktivní.
Mnoho odběratelů, nezávislé proudy: Každý nový odběratel obdrží úplný soubor hodnot od začátku, nezávisle na ostatních odběratelích. To vytváří nezávislé datové proudy pro každého odběratele.

Příklad struktury studeného observable (teoreticky):

// Představte si, že je to nějaký "generátor" hodnot
function generateValues() {
  let i = 0;
  return {
    // Metoda, která vrací následující hodnotu (když je požadována)
    next: function() {
      return { value: i++, done: false };
    }
  };
}

// "Observable" - v podstatě jen funkce, která přijímá odběratele
function coldObservableExample(subscriber) {
  const generator = generateValues();

  // Simulace emitování hodnot
  setTimeout(() => {
    subscriber.next(generator.next().value);
  }, 100);

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

  setTimeout(() => {
    subscriber.complete(); // Ukončení proudu
  }, 300);

  // Vrací objekt odběru (pro odhlášení)
  return {
    unsubscribe: () => {
      console.log('Odhlášení');
      // Tady mohla být logika pro ukončení generátoru/časovačů
    }
  };
}

// Odběratel 1
const subscription1 = coldObservableExample({
  next: (value) => console.log('Odběratel 1 obdržel:', value),
  error: (err) => console.error('Chyba 1:', err),
  complete: () => console.log('Odběratel 1 dokončen')
});

// Odběratel 2 (bude začínat od začátku)
setTimeout(() => {
  const subscription2 = coldObservableExample({
    next: (value) => console.log('Odběratel 2 obdržel:', value),
    error: (err) => console.error('Chyba 2:', err),
    complete: () => console.log('Odběratel 2 dokončen')
  });
}, 150);

// Odhlášení prvního odběratele
setTimeout(() => {
  subscription1.unsubscribe();
}, 250);

Na rozdíl od horkého Observable (Hot Observable), který začíná emitovat hodnoty okamžitě, bez ohledu na odběratele, a všichni odběratelé dostávají hodnoty od okamžiku přihlášení, studený Observable uchovává a reprodukuje celý datový tok pro každého nového odběratele. Tato vlastnost ho přibližuje ke konceptu Observable v JavaScriptu (v kontextu RxJS a podobných knihoven).

Zjednodušené srovnání:

Charakteristika	Studený Observable	Horký Observable
Začátek emitování	Při přihlášení	Ihned
Tok pro odběratele	Plný datový tok pro každého	Hodnoty od okamžiku přihlášení
Použití	HTTP požadavky, čtení souborů, iterace	DOM události, webové sockety, časovače

S jakou datovou strukturou je si podobný objekt Observable v JavaScriptu?