A que estrutura de dados em JavaScript o objeto…

A estrutura de dados Observable frio (do inglês Cold Observable), que é um conceito de programação reativa (por exemplo, na biblioteca RxJS).

Semelhanças principais:

Natureza preguiçosa: O Observable começa a emitir valores apenas quando há um assinante. Sem assinatura, o Observable não está ativo.
Múltiplos assinantes, fluxos independentes: Cada novo assinante recebe o conjunto completo de valores desde o início, independentemente de outros assinantes. Isso cria fluxos de dados independentes para cada assinante.

Exemplo de estrutura de um observable frio (conceitualmente):

// Imagine que isto é um "gerador" de valores
function generateValues() {
  let i = 0;
  return {
    // Método que retorna o próximo valor (quando solicitado)
    next: function() {
      return { value: i++, done: false };
    }
  };
}

// "Observable" - na essência, apenas uma função que aceita um assinante
function coldObservableExample(subscriber) {
  const generator = generateValues();

  // Simulação de emissão de valores
  setTimeout(() => {
    subscriber.next(generator.next().value);
  }, 100);

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

  setTimeout(() => {
    subscriber.complete(); // Finalização do fluxo
  }, 300);

  // Retorna um objeto de assinatura (para cancelar)
  return {
    unsubscribe: () => {
      console.log('Desinscrição');
      // Aqui poderia ir a lógica para parar o gerador/temporizadores
    }
  };
}

// Assinante 1
const subscription1 = coldObservableExample({
  next: (value) => console.log('Assinante 1 recebeu:', value),
  error: (err) => console.error('Erro 1:', err),
  complete: () => console.log('Assinante 1 finalizado')
});

// Assinante 2 (começará a receber valores desde o início)
setTimeout(() => {
  const subscription2 = coldObservableExample({
    next: (value) => console.log('Assinante 2 recebeu:', value),
    error: (err) => console.error('Erro 2:', err),
    complete: () => console.log('Assinante 2 finalizado')
  });
}, 150);

// Cancelar assinatura do primeiro assinante
setTimeout(() => {
  subscription1.unsubscribe();
}, 250);

Ao contrário do Observable quente (Hot Observable), que começa a emitir valores imediatamente, independentemente dos assinantes, e todos os assinantes recebem os valores desde o momento da assinatura, o Observable frio mantém e reproduz o fluxo completo de dados para cada novo assinante. Essa característica aproxima-o do conceito de Observable em JavaScript (no contexto do RxJS e bibliotecas similares).

Comparação (simplificada):

Característica	Observable frio	Observable quente
Início da emissão	Na assinatura	Imediatamente
Fluxo para assinantes	Fluxo completo para cada um	Valores desde o momento da assinatura
Uso	Requisições HTTP, leitura de arquivos, iteração	Eventos DOM, websockets, temporizadores

A que estrutura de dados em JavaScript o objeto Observable se assemelha?