Kāda datu struktūra JavaScript ir līdzīga Observable…

Datu struktūra auksts Observable (no angļu valodas. Cold Observable), kas ir koncepcija no reaktīvās programmēšanas (piemēram, RxJS bibliotēkā).

Galvenās līdzības:

Lazy daba: Observable sāk emitēt vērtības tikai tad, kad ir abonents (subscriber). Kamēr nav abonēšanas, Observable nav aktīvs.
Daudz abonentu, neatkarīgi plūsmas: Katrs jauns abonents saņem pilnu vērtību kopumu, sākot no paša sākuma, neatkarīgi no citiem abonentiem. Tas rada neatkarīgas datu plūsmas katram abonentam.

Piemērs auksta observable struktūrai (konceptuāli):

// Iedomājieties, ka tas ir kāds "ģenerators" vērtībām
function generateValues() {
  let i = 0;
  return {
    // Metode, kas atgriež nākamo vērtību (kad to pieprasa)
    next: function() {
      return { value: i++, done: false };
    }
  };
}

// "Observable" - būtībā, vienkārši funkcija, kas pieņem abonentu
function coldObservableExample(subscriber) {
  const generator = generateValues();

  // Vērtību emitēšanas emulācija
  setTimeout(() => {
    subscriber.next(generator.next().value);
  }, 100);

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

  setTimeout(() => {
    subscriber.complete(); // Plūsmas noslēgums
  }, 300);

  // Atgriež abonēšanas objektu (lai atceltu abonēšanu)
  return {
    unsubscribe: () => {
      console.log('Atteikšanās');
      // Šeit varētu būt loģika generatora/taimeru slēgšanai
    }
  };
}

// Abonents 1
const subscription1 = coldObservableExample({
  next: (value) => console.log('Abonents 1 saņēma:', value),
  error: (err) => console.error('Kļūda 1:', err),
  complete: () => console.log('Abonents 1 pabeigts')
});

// Abonents 2 (sāks saņemt vērtības no paša sākuma)
setTimeout(() => {
  const subscription2 = coldObservableExample({
    next: (value) => console.log('Abonents 2 saņēma:', value),
    error: (err) => console.error('Kļūda 2:', err),
    complete: () => console.log('Abonents 2 pabeigts')
  });
}, 150);

// Pārtraukšana pirmā abonenta
setTimeout(() => {
  subscription1.unsubscribe();
}, 250);

Atšķirībā no karstā Observable (Hot Observable), kas sāk emitēt vērtības uzreiz, neatkarīgi no abonentiem, un visi abonenti saņem vērtības no abonēšanas brīža, auksts Observable saglabā un reproducē pilnu datu plūsmu katram jaunajam abonentam. Tieši šī īpašība to tuvinās Observable koncepcijai JavaScript (RxJS un līdzīgās bibliotēkās).

Salīdzinājums (vienkāršots):

Raksturlielums	Auksts Observable	Karsts Observable
Sākuma emitēšana	Pie abonēšanas	Uzreiz
Plūsma abonentiem	Pilna datu plūsma katram	Vērtības no abonēšanas brīža
Lietojums	HTTP pieprasījumi, failu lasīšana, iterācija	DOM notikumi, tīmekļa soketi, taimeri

Kāda datu struktūra JavaScript ir līdzīga Observable objektam?