Desafio JavaScript

Simulador de event loop com filas

Enunciado

Implemente uma função simularEventLoop que recebe um array de tarefas e simula a ordem de execução do event loop. Cada tarefa é um objeto com tipo ('sync', 'micro', 'macro') e id. A função deve retornar um array com os ids na ordem em que seriam executados. Considere que todas as tarefas são agendadas no início e que não há novas tarefas criadas durante a execução.

Requisitos

  • Processar todas as tarefas 'sync' primeiro, na ordem original
  • Depois processar todas as 'micro' na ordem original
  • Por último processar todas as 'macro' na ordem original
  • Retornar um array com os ids na ordem de execução

Código inicial

function simularEventLoop(tarefas) {
  // Seu código aqui
}

// Exemplo de uso:
const tarefas = [
  { tipo: 'macro', id: 'A' },
  { tipo: 'sync', id: 'B' },
  { tipo: 'micro', id: 'C' },
  { tipo: 'sync', id: 'D' },
  { tipo: 'micro', id: 'E' },
  { tipo: 'macro', id: 'F' }
];
console.log(simularEventLoop(tarefas)); // ['B', 'D', 'C', 'E', 'A', 'F']

Saída esperada

['B', 'D', 'C', 'E', 'A', 'F']
Ver dica

Separe as tarefas em três arrays por tipo, mantendo a ordem. Depois concatene na ordem: sync, micro, macro.

Mostrar solução 
function simularEventLoop(tarefas) {
  // Filtra tarefas síncronas, microtarefas e macrotarefas
  const sync = tarefas.filter(t => t.tipo === 'sync').map(t => t.id);
  const micro = tarefas.filter(t => t.tipo === 'micro').map(t => t.id);
  const macro = tarefas.filter(t => t.tipo === 'macro').map(t => t.id);
  
  // Concatena na ordem correta: sync, micro, macro
  return [...sync, ...micro, ...macro];
}

// Teste
const tarefas = [
  { tipo: 'macro', id: 'A' },
  { tipo: 'sync', id: 'B' },
  { tipo: 'micro', id: 'C' },
  { tipo: 'sync', id: 'D' },
  { tipo: 'micro', id: 'E' },
  { tipo: 'macro', id: 'F' }
];
console.log(simularEventLoop(tarefas)); // ['B', 'D', 'C', 'E', 'A', 'F']

Passo a passo

  1. A função simularEventLoop recebe um array de tarefas.
  2. Usamos filter para separar as tarefas por tipo, mantendo a ordem original de cada grupo.
  3. Mapeamos cada grupo para extrair apenas os ids.
  4. Concatenamos os arrays na ordem: primeiro sync, depois micro, por último macro.
  5. Retornamos o array resultante.
  6. O teste com o exemplo mostra a ordem correta: síncronos primeiro, depois microtarefas, depois macrotarefas.

Por que funciona

A simulação reflete a prioridade do event loop: tarefas síncronas são executadas imediatamente, microtarefas têm prioridade sobre macrotarefas. Como todas as tarefas são agendadas no início, a ordem dentro de cada fila é preservada (FIFO).

Erros comuns

  • Não preservar a ordem original dentro de cada tipo: Usar sort ou reverse acidentalmente.
  • Misturar micro e macro: Lembrar que microtarefas vêm antes de macrotarefas.
  • Esquecer de mapear para id: Retornar objetos em vez de strings.

Outra forma de resolver

Usar reduce para agrupar em um objeto:

function simularEventLoop(tarefas) {
  const grupos = tarefas.reduce((acc, t) => {
    acc[t.tipo] = acc[t.tipo] || [];
    acc[t.tipo].push(t.id);
    return acc;
  }, {});
  return [...(grupos.sync || []), ...(grupos.micro || []), ...(grupos.macro || [])];
}

Essa abordagem é útil se houver muitos tipos de tarefas.

Saída esperada

['B', 'D', 'C', 'E', 'A', 'F']