Como o Node.js funciona por debaixo dos panos?

7 min readFeb 3, 2024

Neste artigo, pretendo discutir e apresentar a você, caro leitor, alguns pontos cruciais que considero essenciais para todo desenvolvedor de software que, de alguma maneira, lida com Node.js. O objetivo é proporcionar uma compreensão mais aprofundada de suas vantagens e desvantagens, a fim de capacitar você a tomar decisões técnicas mais embasadas para o seu projeto e cenário de uso.

O Node.js é uma plataforma construída sobre o motor V8 do Google Chrome, que é um interpretador JavaScript de código aberto de alto desempenho. Vamos dar uma olhada em como o Node.js funciona por debaixo dos panos:

Motor V8

O primeiro tópico é o mecanismo de execução de JavaScript desenvolvido pelo Google, chamado V8, que compila o código JavaScript em código de máquina de forma eficiente.

O V8 é incorporado ao código-fonte do Node.js. Isso significa que o Node.js inclui o V8 como uma parte essencial de sua arquitetura. A integração é feita através de interfaces que permitem que o Node.js chame funções do V8 e se comunique com o motor JavaScript.

Ou seja, o Node.js fornece APIs que permitem a comunicação entre o código JavaScript e o código em C++ que interage diretamente com o V8. Isso é útil para implementar funcionalidades específicas e otimizações que são necessárias para o ambiente Node.js.

Em resumo, o Node.js utiliza o V8 como seu motor JavaScript subjacente, tirando proveito de sua velocidade de execução, otimizações, coleta de lixo e conformidade com as especificações ECMAScript. Essa integração permite que o Node.js forneça um ambiente de execução rápido e eficiente para o JavaScript no lado do servidor.

Arquitetura de Event Loop

Uma das características do Node.js é seu comportamento Single-Threaded. Com base nessa característica, foi arquitetado um sistema de execução de operações para o Node chamado de Non-blocking I/O. Esse nome se dá devido ao seu comportamento, no qual o Node opera em um modelo de execução único (single) e não bloqueante. Isso significa que, enquanto um evento está sendo processado, o programa não fica parado, aguardando a conclusão da operação de entrada e saída (I/O). Em vez disso, ele delega tarefas de I/O para um sistema de eventos chamado Event Loop.

O Event Loop, por sua vez, trabalha com operações de forma assíncrona, permitindo que as operações não se bloqueiem umas às outras. Assim, enquanto uma operação está sendo finalizada, o Event Loop busca outras na pilha para serem executadas.

Para exemplicar, suponha que temos um arquivo chamado “exemplo.txt” e queremos lê-lo de forma assíncrona usando o módulo fs (File System) do Node.js. Aqui está um exemplo de código:

const fs = require('fs');

// Leitura assíncrona de arquivo
fs.readFile('exemplo.txt', 'utf8', (err, data) => {
  if (err) {
    console.error('Erro na leitura do arquivo:', err);
    return;
  }

  console.log('Conteúdo do arquivo:', data);
});

console.log('Operação assíncrona iniciada.');

Neste exemplo, readFile é uma função assíncrona que recebe o nome do arquivo, a codificação e uma função de retorno de chamada.
O event loop entra em cena quando a operação de leitura é iniciada. O código não espera que a leitura seja concluída e continua a executar outras operações.

Então, o evento de leitura do arquivo é iniciado, e o Node.js registra a operação no event loop. Enquanto aguarda a conclusão da operação de leitura, o código continua a executar outras operações, como o console.log('Operação assíncrona iniciada.').

Quando a leitura do arquivo é concluída, o callback é chamado e o resultado é tratado.

Essa abordagem permite que o Node.js lide com muitas operações de forma eficiente, sem bloquear o thread principal, aproveitando ao máximo as operações de I/O assíncronas.

Libuv

A Libuv, é uma biblioteca multiplataforma em C, que fornece suporte para operações de I/O (entrada e saída) de forma assíncrona.

Ela foi desenvolvida como parte do projeto Node.js para lidar com a natureza assíncrona e orientada a eventos do ambiente, como uma camada abstrata de baixo nível, que manipula os eventos de I/O assíncronos, e facilita a interação com o sistema de arquivos e o sistema operacional.

Com ela o Node pode executar de forma eficiente operações como:

Leitura e escrita de arquivos;
Manipulação de sockets;
Funcionalidades para lidar com operações e interações de rede, como criação de servidores e clientes TCP/UDP;
Criação e gerenciamento de timers para agendar tarefas no futuro, bem como a manipulação de eventos do sistema operacional;
Pool de threads, para manipular operações intensivas em CPU de forma mais eficiente, evitando que bloqueiem o loop de eventos principal.

Ao utilizar a Libuv, o Node.js pode realizar operações assíncronas de forma eficiente e escalável. A biblioteca é uma parte fundamental da arquitetura do Node.js, permitindo que ele lide com muitas conexões simultâneas sem a necessidade de criar uma nova thread para cada uma. Isso contribui para a eficiência e desempenho característicos do Node.js em ambientes de rede e I/O intensivos.

Gerenciamento de Módulos

O Node.js trabalha com um sistema de módulos de código reutilizáveis. Para isto ele utiliza o CommonJS, uma especificação para organização e gerenciamento de módulos para o JavaScript no lado do servidor, que o Node a adotou como seu sistema padrão de módulos.

Esta especificação, possui características principais, que todo desenvolvedor que já usou Node.js deve conhecer. Elas são o require e o module.exports.

O require, é uma função essencial do CommonJS, para importação (“requerer”) de módulos de código dentro de seus arquivos. Quando você usa o require, o Node procura o módulo especificado dentro de seu ambiente e o carrega no seu programa. Como no exemplo abaixo:

const lib = require('my-favorite-lib');

Dessa forma, as funcionalidades do código pertencente a este módulo, podem ser utilizadas dentro de seu arquivo ou projeto.

E também temos o module.exports, utilizado para exportar funcionalidades de um módulo, permitindo que outros módulos possam acessar os métodos e funcionalidades provenientes do mesmo, através de sua importação:

// No arquivo "modulo.js"
const funcao = () => {
  // ...
};

module.exports = funcao;

// No arquivo que requer "modulo.js"
const funcaoImportada = require('./modulo.js');

Essencialmente, o CommonJS oferece uma maneira padronizada de estruturar, importar e exportar módulos em JavaScript, tornando o código mais modular e fácil de gerenciar. Isso é particularmente útil em ambientes de servidor, onde a modularidade é crucial para lidar com projetos complexos e extensos.

CallBack Functions

As callback functions são um conceito central no Node.js, uma vez que a plataforma é projetada para operações assíncronas e não bloqueantes. Callbacks são funções passadas como argumentos para outras funções e executadas após a conclusão de uma operação assíncrona.

No contexto do Node.js, as callbacks são frequentemente utilizadas para lidar com operações de I/O, como leitura de arquivos, chamadas de banco de dados e requisições de rede. A ideia é que, em vez de esperar que uma operação seja concluída antes de prosseguir para a próxima, você passa uma função callback que será executada quando a operação assíncrona for finalizada.

Para exemplificar, vamos supor que você esteja usando uma biblioteca de banco de dados no Node.js, como o mongodb usando o MongoDB como exemplo. Neste caso, você pode usar callbacks para lidar com operações de banco de dados assíncronas. Aqui está um exemplo:

const MongoClient = require('mongodb').MongoClient;

// URL de conexão com o banco de dados
const url = 'mongodb://localhost:27017';

// Nome do banco de dados
const dbName = 'meuBancoDeDados';

// Função de callback para manipular o resultado da operação
const callback = (err, client) => {
  if (err) {
    console.error('Erro ao conectar ao banco de dados:', err);
    return;
  }

  console.log('Conexão bem-sucedida ao banco de dados');

  // Aqui você pode realizar operações no banco de dados

  // Fechar a conexão quando as operações forem concluídas
  client.close();
};

// Conectar ao banco de dados
MongoClient.connect(url, { useNewUrlParser: true, useUnifiedTopology: true }, (err, client) => {
  callback(err, client);
});

A função de callback (callback) recebe dois parâmetros, err e client. Se houver um erro, ele será impresso no console, caso contrário, uma mensagem de sucesso será exibida.
Dentro da função de callback, você pode realizar operações no banco de dados, como inserções, consultas, atualizações, etc. Depois, a conexão com o banco de dados é fechada.

Em uma aplicação real, você lidaria com mais operações dentro da função de callback e, idealmente, utilizaria Promises ou async/await para uma gestão mais clara do código assíncrono.

As callbacks permitem lidar eficientemente com operações assíncronas no Node.js, tornando-o adequado para ambientes que exigem alta concorrência e eficiência em operações de I/O. No entanto, o uso excessivo de callbacks pode levar a um fenômeno conhecido como “callback hell” (aninhamento excessivo de callbacks), e para lidar com isso, surgiram outras abordagens, como Promises e async/await, que fornecem uma maneira mais limpa e estruturada de lidar com operações assíncronas.

Após discutir estes tópicos arquiteturais principais do Node.js. Podemos ter uma visão de seu fluxo de funcionamento como mostra este diagrama abaixo:

Enfim…

Todos estes pontos fazem do Node.js uma escolha popular atraente para o desenvolvimento de aplicações web. Sua eficiência assíncrona, a unificação do JavaScript no frontend e backend, o ecossistema NPM robusto, a escalabilidade, o compartilhamento de código, o desenvolvimento rápido, a comunidade ativa e o suporte a aplicações em tempo real são fatores que tornam o Node.js uma opção popular para criar aplicações web modernas e eficientes.
A escolha, no entanto, deve ser baseada nas necessidades específicas do projeto e nas habilidades da equipe de desenvolvimento. Espero que com os assuntos debatidos neste artigo, você consiga tomar as melhores decisões para o seu projeto.