O loop de eventos é um conceito central do Node.js que permite lidar com operações assíncronas com eficiência. Aqui está uma explicação simplificada de como funciona:

1. Natureza de rosca única

Node.js opera em um único thread. Isso significa que ele só pode executar um trecho de código por vez. No entanto, o Node.js foi projetado para lidar com muitas operações simultaneamente sem exigir vários threads.

2. E/S sem bloqueio

Node.js usa operações de E/S sem bloqueio. Quando o Node.js executa tarefas como ler arquivos, consultar um banco de dados ou fazer solicitações de rede, ele não espera que essas tarefas sejam concluídas antes de passar para a próxima tarefa. Em vez disso, ele continua executando outro código enquanto essas tarefas estão sendo processadas.

3. Mecanismo de Loop de Eventos

O loop de eventos é responsável por gerenciar a execução do código e tratar eventos assíncronos. Ele verifica continuamente a “fila” de tarefas e decide quais executar. Aqui está uma análise passo a passo:

• Initialize: quando um aplicativo Node.js é iniciado, ele inicializa e configura o ambiente.
• Fase de execução: Node.js executa qualquer código inicial de forma síncrona. Se houver tarefas assíncronas (como leitura de arquivos ou solicitações HTTP), elas serão repassadas às APIs do sistema.
• Fases do loop de eventos: O loop de eventos tem várias fases e processa tarefas em cada fase em uma ordem específica:
  • Timers Phase: Executa callbacks agendados por setTimeout() e setInterval().
  • Fase de retornos de chamada de E/S: Executa retornos de chamada para operações de E/S, como leituras de arquivos ou solicitações de rede.
  • Idle, Prepare Phase: Fase interna usada para tarefas do sistema.
  • Poll Phase: Recupera novos eventos de I/O, executando seus callbacks. Se a fila de enquete estiver vazia, ele verificará se há retornos de chamada na fila setImmediate().
  • Check Phase: Executa callbacks agendados por setImmediate().
  • Fase de retorno de chamada de fechamento: Lida com eventos de fechamento, como aqueles emitidos por socket.on('close').
• Verificar novamente e sair: Se o loop de eventos não tiver mais tarefas para processar, ele será encerrado, permitindo que o programa seja encerrado. Se ainda houver tarefas pendentes, ela continuará em execução.

4. Fila de retorno de chamada

As tarefas assíncronas, uma vez concluídas, enviam seus retornos de chamada para uma fila. O loop de eventos seleciona esses retornos de chamada da fila e os executa em ordem.

5. Fila de microtarefas (próximo tique)

Além da fila principal, há também uma fila de microtarefas (ou fila de próximo tick) onde os retornos de chamada agendados com process.nextTick() ou manipuladores .then() de promessas são enfileirados. As microtarefas têm prioridade sobre os retornos de chamada regulares, o que significa que são executadas após a conclusão da operação atual, mas antes que o loop de eventos passe para a próxima fase.

Exemplo

Aqui está um exemplo simples para ilustrar como o loop de eventos funciona:

const fs = require('fs');

console.log('Start');

fs.readFile('file.txt', (err, data) => {
  if (err) throw err;
  console.log('File read complete');
});

console.log('End');

Saída:

Start
End
File read complete

Explicação:

1. console.log('Iniciar'); e console.log('End'); são executados de forma síncrona.
2. fs.readFile inicia uma operação assíncrona de leitura de arquivo e continua executando a próxima linha de código sem esperar.
3. Depois que a operação de leitura do arquivo for concluída, seu retorno de chamada (console.log('File read complete');) será enviado para a fila de retorno de chamada do loop de eventos.
4. O loop de eventos processa o retorno de chamada após a conclusão da execução do código síncrono.

O loop de eventos permite que o Node.js lide com eficiência com muitas operações ao mesmo tempo, apesar de ser de thread único, delegando operações ao sistema e manipulando seus resultados de forma assíncrona.

O Event Loop orquestra a execução de tarefas, priorizando a Microtask Queue para garantir que promessas e operações relacionadas sejam resolvidas rapidamente antes de passar para as tarefas na Main Task Queue (Tarefa Macro).

Essa dinâmica permite que o JavaScript lide com comportamento assíncrono complexo em um ambiente de thread único.