S akou dátovou štruktúrou je podobný objekt…

Štruktúra dátovej štruktúry studeného Observable (anglicky Cold Observable), ktorá je konceptom z reaktívneho programovania (napríklad v knižnici RxJS).

Kľúčové podobnosti:

Lenivá povaha: Observable začína emitovať hodnoty až pri existencii odberateľa (subscriber). Bez odberateľa, Observable nie je aktívny.
Mnoho odberateľov, nezávislé prúdy: Každý nový odberateľ dostáva úplný súbor hodnôt od začiatku, nezávisle od ostatných odberateľov. To vytvára nezávislé prúdy dát pre každého odberateľa.

Príklad štruktúry studeného observable (teoreticky):

// Predstavte si, že je to nejaký "generátor" hodnôt
function generateValues() {
  let i = 0;
  return {
    // Metóda, ktorá vracia nasledujúcu hodnotu (keď je požadovaná)
    next: function() {
      return { value: i++, done: false };
    }
  };
}

// "Observable" - v podstate len funkcia, ktorá prijíma odberateľa
function coldObservableExample(subscriber) {
  const generator = generateValues();

  // Imitačné emitovanie hodnôt
  setTimeout(() => {
    subscriber.next(generator.next().value);
  }, 100);

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

  setTimeout(() => {
    subscriber.complete(); // Ukončenie prúdu
  }, 300);

  // Vrátime objekt odberu (pre odhlásenie)
  return {
    unsubscribe: () => {
      console.log('Odhlásenie');
      // Tu môže byť logika na zastavenie generátora/časovačov
    }
  };
}

// Odberateľ 1
const subscription1 = coldObservableExample({
  next: (value) => console.log('Odberateľ 1 dostal:', value),
  error: (err) => console.error('Chyba 1:', err),
  complete: () => console.log('Odberateľ 1 ukončený')
});

// Odberateľ 2 (začne dostávať hodnoty od začiatku)
setTimeout(() => {
  const subscription2 = coldObservableExample({
    next: (value) => console.log('Odberateľ 2 dostal:', value),
    error: (err) => console.error('Chyba 2:', err),
    complete: () => console.log('Odberateľ 2 ukončený')
  });
}, 150);

// Odhlásenie prvého odberateľa
setTimeout(() => {
  subscription1.unsubscribe();
}, 250);

Na rozdiel od horúceho Observable (Hot Observable), ktorý začína emitovať hodnoty okamžite, nezávisle od odberateľov, a všetci odberatelia dostávajú hodnoty od okamihu prihlásenia, studené Observable si uchováva a reprodukuje celý tok dát pre každého nového odberateľa. Táto vlastnosť ho približuje ku konceptu Observable v JavaScripte (v kontexte RxJS a podobných knižníc).

Zhrnutie (zjednodušené):

Charakteristika	Studené Observable	Horúce Observable
Začiatok emitovania	Pri prihlásení	Ihneď
Tok pre odberateľov	Plný tok dát pre každého	Hodnoty od okamihu prihlásenia
Použitie	HTTP požiadavky, čítanie súborov, iterácie	DOM udalosti, webové sockety, časovače

S akou dátovou štruktúrou je podobný objekt Observable v JavaScripte?