¿A qué estructura de datos en JavaScript se asemeja…

La estructura de datos Observable en frío (del inglés Cold Observable), que es una concepto de la programación reactiva (por ejemplo, en la biblioteca RxJS).

Similitudes clave:

Naturaleza perezosa: El Observable comienza a emitir valores solo cuando hay un suscriptor. Sin suscripción, el Observable no está activo.
Múltiples suscriptores, flujos independientes: Cada nuevo suscriptor recibe el conjunto completo de valores desde el principio, independientemente de otros suscriptores. Esto crea flujos de datos independientes para cada suscriptor.

Ejemplo de estructura de un observable en frío (conceptualmente):

// Imagina que esto es un "generador" de valores
function generateValues() {
  let i = 0;
  return {
    // Método que devuelve el siguiente valor (cuando se solicita)
    next: function() {
      return { value: i++, done: false };
    }
  };
}

// "Observable" - en esencia, simplemente una función que recibe un suscriptor
function coldObservableExample(subscriber) {
  const generator = generateValues();

  // Emulación de emisión de valores
  setTimeout(() => {
    subscriber.next(generator.next().value);
  }, 100);

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

  setTimeout(() => {
    subscriber.complete(); // Finalización del flujo
  }, 300);

  // Devolvemos un objeto de suscripción (para cancelar)
  return {
    unsubscribe: () => {
      console.log('Desubscripción');
      // Aquí podría ir la lógica para detener el generador/temporizadores
    }
  };
}

// Suscriptor 1
const subscription1 = coldObservableExample({
  next: (value) => console.log('Suscriptor 1 recibió:', value),
  error: (err) => console.error('Error 1:', err),
  complete: () => console.log('Suscriptor 1 finalizado')
});

// Suscriptor 2 (comenzará a recibir valores desde el principio)
setTimeout(() => {
  const subscription2 = coldObservableExample({
    next: (value) => console.log('Suscriptor 2 recibió:', value),
    error: (err) => console.error('Error 2:', err),
    complete: () => console.log('Suscriptor 2 finalizado')
  });
}, 150);

// Cancelación del primer suscriptor
setTimeout(() => {
  subscription1.unsubscribe();
}, 250);

A diferencia del Observable caliente (Hot Observable), que comienza a emitir valores inmediatamente, independientemente de los suscriptores, y todos los suscriptores reciben los valores desde el momento de la suscripción, el Observable en frío guarda y reproduce el flujo completo de datos para cada nuevo suscriptor. Esta característica lo acerca a la concepción de Observable en JavaScript (en el contexto de RxJS y bibliotecas similares).

Comparación (simplificada):

Característica	Observable en frío	Observable caliente
Inicio de emisión	En la suscripción	Inmediatamente
Flujo para suscriptores	Flujo completo para cada uno	Valores desde el momento de la suscripción
Uso	Solicitudes HTTP, lectura de archivos, iteración	Eventos DOM, websockets, temporizadores

¿A qué estructura de datos en JavaScript se asemeja el objeto Observable?