A quale struttura dati in JavaScript è simile…

La struttura dati Observable a freddo (dall'inglese Cold Observable), che è un concetto della programmazione reattiva (ad esempio, nella libreria RxJS).

Principali somiglianze:

Natura pigra: L'Observable inizia a emettere valori solo quando c'è un sottoscrittore. Senza sottoscrizione, l'Observable non è attivo.
Molti sottoscrittori, flussi indipendenti: Ogni nuovo sottoscrittore riceve l'intero insieme di valori dall'inizio, indipendentemente dagli altri sottoscrittori. Questo crea flussi di dati indipendenti per ogni sottoscrittore.

Esempio di struttura di un observable a freddo (concettualmente):

// Immagina che sia un "generatore" di valori
function generateValues() {
  let i = 0;
  return {
    // Metodo che restituisce il prossimo valore (quando richiesto)
    next: function() {
      return { value: i++, done: false };
    }
  };
}

// "Observable" - in sostanza, semplicemente una funzione che accetta un sottoscrittore
function coldObservableExample(subscriber) {
  const generator = generateValues();

  // Simulazione di emissione di valori
  setTimeout(() => {
    subscriber.next(generator.next().value);
  }, 100);

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

  setTimeout(() => {
    subscriber.complete(); // Fine del flusso
  }, 300);

  // Restituisce un oggetto di sottoscrizione (per disiscriversi)
  return {
    unsubscribe: () => {
      console.log('Disiscrizione');
      // Qui potrebbe esserci la logica per fermare il generatore/temporizzatori
    }
  };
}

// Sottoscrittore 1
const subscription1 = coldObservableExample({
  next: (value) => console.log('Sottoscrittore 1 ha ricevuto:', value),
  error: (err) => console.error('Errore 1:', err),
  complete: () => console.log('Sottoscrittore 1 terminato')
});

// Sottoscrittore 2 (inizierà a ricevere valori dall'inizio)
setTimeout(() => {
  const subscription2 = coldObservableExample({
    next: (value) => console.log('Sottoscrittore 2 ha ricevuto:', value),
    error: (err) => console.error('Errore 2:', err),
    complete: () => console.log('Sottoscrittore 2 terminato')
  });
}, 150);

// Disiscrizione del primo sottoscrittore
setTimeout(() => {
  subscription1.unsubscribe();
}, 250);

A differenza dell'Observable caldo (Hot Observable), che inizia a emettere valori immediatamente, indipendentemente dai sottoscrittori, e tutti i sottoscrittori ricevono i valori dall'istante della sottoscrizione, il Cold Observable conserva e riproduce l'intero flusso di dati per ogni nuovo sottoscrittore. Questa caratteristica lo avvicina al concetto di Observable in JavaScript (nel contesto di RxJS e librerie simili).

Confronto (semplificato):

Caratteristica	Cold Observable	Hot Observable
Inizio emissione	Alla sottoscrizione	Immediatamente
Flusso per i sottoscrittori	Flusso completo per ciascuno	Valori dall'istante della sottoscrizione
Uso	Richieste HTTP, lettura di file, iterazione	Eventi DOM, WebSocket, timer

A quale struttura dati in JavaScript è simile l'oggetto Observable?