La ce structură de date din JavaScript este similar…

Structura de date Observable rece (din engleză Cold Observable), care este o concepție din programarea reactivă (de exemplu, în biblioteca RxJS).

Similarități cheie:

Natură leneșă: Un Observable începe să emită valori doar atunci când există un abonat. Fără abonament, Observable nu este activ.
Multiple abonamente, fluxuri independente: Fiecare nou abonat primește setul complet de valori de la început, independent de alți abonați. Acest lucru creează fluxuri de date independente pentru fiecare abonat.

Exemplu de structură a unui Cold Observable (conceptual):

// Imaginează-ți că acesta este un "generator" de valori
function generateValues() {
  let i = 0;
  return {
    // Metodă care returnează următoarea valoare (când este solicitată)
    next: function() {
      return { value: i++, done: false };
    }
  };
}

// "Observable" - în esență, doar o funcție care acceptă un abonat
function coldObservableExample(subscriber) {
  const generator = generateValues();

  // Emulare a emiterii valorilor
  setTimeout(() => {
    subscriber.next(generator.next().value);
  }, 100);

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

  setTimeout(() => {
    subscriber.complete(); // Încheierea fluxului
  }, 300);

  // Returnează un obiect de abonare (pentru dezabonare)
  return {
    unsubscribe: () => {
      console.log('Dezabonare');
      // Aici ar putea fi logica pentru oprirea generatorului/timerelor
    }
  };
}

// Abonat 1
const subscription1 = coldObservableExample({
  next: (value) => console.log('Abonat 1 a primit:', value),
  error: (err) => console.error('Eroare 1:', err),
  complete: () => console.log('Abonat 1 finalizat')
});

// Abonat 2 (va începe să primească valori de la început)
setTimeout(() => {
  const subscription2 = coldObservableExample({
    next: (value) => console.log('Abonat 2 a primit:', value),
    error: (err) => console.error('Eroare 2:', err),
    complete: () => console.log('Abonat 2 finalizat')
  });
}, 150);

// Dezabonare a primului abonat
setTimeout(() => {
  subscription1.unsubscribe();
}, 250);

În contrast cu Observable-ul cald (Hot Observable), care începe să emită valori imediat, indiferent de abonați, și toți abonații primesc valorile de la momentul abonării, Cold Observable păstrează și reproduce fluxul complet de date pentru fiecare nou abonat. Această caracteristică îl apropie de conceptul de Observable în JavaScript (în contextul RxJS și bibliotecilor similare).

Comparare (simplificată):

Caracteristică	Cold Observable	Hot Observable
Începutul emiterii	La abonare	Imediat
Flux pentru abonați	Flux complet pentru fiecare	Valori de la momentul abonării
Utilizare	Cereri HTTP, citirea fișierelor, iterație	Evenimente DOM, web-socket-uri, temporizatoare

La ce structură de date din JavaScript este similar obiectul Observable?