To which data structure in JavaScript is the…

The structure of a cold Observable (from the English term), which is a concept from reactive programming (for example, in the RxJS library).

Key similarities:

Lazy nature: Observable starts emitting values only when there is a subscriber. Until there is a subscription, the Observable is inactive.
Multiple subscribers, independent streams: Each new subscriber receives the full set of values from the beginning, regardless of other subscribers. This creates independent data streams for each subscriber.

Example of a cold observable structure (conceptually):

// Imagine this as a "value generator"
function generateValues() {
  let i = 0;
  return {
    // Method that returns the next value when requested
    next: function() {
      return { value: i++, done: false };
    }
  };
}

// "Observable" - essentially, just a function that takes a subscriber
function coldObservableExample(subscriber) {
  const generator = generateValues();

  // Emulation of value emission
  setTimeout(() => {
    subscriber.next(generator.next().value);
  }, 100);

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

  setTimeout(() => {
    subscriber.complete(); // End of stream
  }, 300);

  // Return a subscription object (for unsubscription)
  return {
    unsubscribe: () => {
      console.log('Unsubscribed');
      // Logic for generator/timer cleanup could go here
    }
  };
}

// Subscriber 1
const subscription1 = coldObservableExample({
  next: (value) => console.log('Subscriber 1 received:', value),
  error: (err) => console.error('Error 1:', err),
  complete: () => console.log('Subscriber 1 completed')
});

// Subscriber 2 (will start receiving values from the beginning)
setTimeout(() => {
  const subscription2 = coldObservableExample({
    next: (value) => console.log('Subscriber 2 received:', value),
    error: (err) => console.error('Error 2:', err),
    complete: () => console.log('Subscriber 2 completed')
  });
}, 150);

// Unsubscribe the first subscriber
setTimeout(() => {
  subscription1.unsubscribe();
}, 250);

Unlike a hot Observable, which starts emitting values immediately regardless of subscribers, and all subscribers receive values from the moment of subscription, a cold Observable saves and reproduces the full data stream for each new subscriber. This characteristic aligns it with the Observable concept in JavaScript (in the context of RxJS and similar libraries).

Comparison (simplified):

Characteristic	Cold Observable	Hot Observable
Emission start	Upon subscription	Immediately
Stream for subscribers	Full data stream for each	Values from the moment of subscription
Usage	HTTP requests, file reading, iteration	DOM events, WebSockets, timers

To which data structure in JavaScript is the Observable object similar?