// stack web · back end · linguagem e plataforma

Node.js: JavaScript fora do navegador

O JavaScript que você escreve para uma página vive dentro de uma aba. Ele não abre arquivo do disco, não escuta porta de rede e não fala com banco de dados. O Node.js pega a mesma linguagem e roda ela direto no sistema operacional, com essas três coisas liberadas.

O que Node.js resolve

Antes do Node.js, quem aprendia JavaScript para o front end tinha que aprender outra linguagem inteira para o back end. Duas sintaxes, dois jeitos de tratar erro, dois times que não liam o código um do outro. O Node.js pegou o V8, o motor que executa JavaScript dentro do Chrome, e empacotou ele como um programa de linha de comando com acesso a disco, rede e processos.

O resultado prático: o mesmo desenvolvedor escreve a tela e o servidor com a linguagem que já conhece. E a máquina ganha um jeito de atender centenas de conexões simultâneas sem abrir uma thread para cada uma, que é o problema que o modelo não bloqueante do Node.js ataca de frente.

Os conceitos que você precisa antes da primeira linha

Runtime. Node.js é o programa que executa o seu JavaScript fora do navegador. A linguagem continua sendo o JavaScript, com a mesma sintaxe da página. O que muda é o que está disponível em volta: some o document, entram disco, rede e argumentos de linha de comando.
Módulo interno. O Node.js já vem com uma biblioteca embutida: node:http para servidor e cliente HTTP, node:fs para arquivo, node:path para caminho. O prefixo node: avisa que o módulo é interno, sem download nenhum envolvido.
Os dois sistemas de módulo. Código em Node.js se divide em arquivos, e existem duas formas de ligar um arquivo no outro. CommonJS usa require() e é o padrão em arquivos .js sem configuração. ESM usa import e vale em arquivos .mjs ou quando o package.json declara "type": "module". Escolha uma por projeto e mantenha.
Event loop. Uma única thread executa o seu código. Quando ele pede uma leitura de disco ou espera uma conexão, o pedido sai da thread e o Node.js segue trabalhando. O resultado volta depois, por callback ou promise. Por isso um servidor Node.js aguenta muita conexão parada esperando, e por isso um cálculo pesado no meio do caminho trava o servidor inteiro.
npm. O gerenciador de pacotes vem instalado junto com o Node.js. Ele baixa biblioteca de terceiro para a pasta node_modules e anota o que foi baixado no package.json. O hello world abaixo não usa npm em momento nenhum, de propósito.

O runtime por dentro: assíncrono, promessas e módulos

A linguagem do Node.js é o JavaScript da página de JavaScript, com os mesmos tipos, funções e classes. O que a página do navegador não te obriga a dominar, e o servidor obriga, é o modelo assíncrono: com uma thread só, o Node.js não pode parar pra esperar disco ou rede, então toda operação lenta devolve o controle e avisa quando terminar.

Promise é o objeto que representa "isso ainda vai terminar": começa pendente e um dia resolve com um valor ou rejeita com um erro. É o tipo que as APIs modernas do Node.js devolvem.
async/await é a sintaxe que deixa o código assíncrono legível: await pausa aquela função (só ela, não o servidor) até a promise resolver. Erro se trata com try/catch normal.
Módulo é o átomo de organização: cada arquivo exporta o que quer mostrar e importa o que precisa. A seção anterior explicou os dois sistemas (require e import). Nos exemplos novos, prefira import.

// assíncrono de verdade em dez linhas (salve como leitor.mjs)
import { readFile } from "node:fs/promises";

async function principal() {
  try {
    const texto = await readFile("dados.txt", "utf8"); // espera SEM travar
    console.log(texto.toUpperCase());
  } catch (erro) {
    console.error("não achei o arquivo:", erro.message);
  }
}

principal();

Essa é a diferença que aparece em entrevista: saber explicar que o await libera a thread pra atender outra requisição enquanto o disco responde. O hello world abaixo usa callback, o estilo mais antigo que você também vai encontrar em código existente.

Hello world: um servidor HTTP em quatro passos

Sem Express, sem framework, sem pacote baixado. Só o Node.js e um arquivo de texto.

Abra o terminal e confira se o Node.js já está na máquina:
```
node --version
npm --version
```
Se aparecerem dois números de versão, pule para o passo 2. Se o terminal responder que o comando não existe, baixe a versão LTS em nodejs.org/en/download. Em 15/08/2026 a LTS é a v24.19.0 e a linha Current é a v26.7.0. Para aprender, pegue a LTS.
Crie uma pasta vazia para o projeto e entre nela:
```
mkdir hello-node
cd hello-node
```

Crie um arquivo chamado server.js dentro dessa pasta, com este conteúdo:

const { createServer } = require('node:http');

const hostname = '127.0.0.1';
const port = 3000;

const server = createServer((req, res) => {
  res.statusCode = 200;
  res.setHeader('Content-Type', 'text/plain');
  res.end('Olá, mundo, direto do Node.js\n');
});

server.listen(port, hostname, () => {
  console.log(`Servidor no ar em http://${hostname}:${port}/`);
});

Cinco linhas fazem o trabalho. createServer recebe uma função que roda a cada requisição que chegar. req é o pedido do navegador, res é a resposta que você monta. listen abre a porta e deixa o processo vivo esperando.

Suba o servidor:
```
node server.js
```
Agora abra http://127.0.0.1:3000 no navegador. Se preferir conferir pelo terminal, abra uma segunda janela e rode:
```
curl -i http://127.0.0.1:3000/
```
Para encerrar, volte ao terminal do servidor e aperte Ctrl + C.

A prova de que funcionou. Três sinais ao mesmo tempo. No terminal aparece a linha Servidor no ar em http://127.0.0.1:3000/ e o cursor não volta, porque o processo continua vivo segurando a porta. No navegador, em 127.0.0.1:3000, aparece o texto Olá, mundo, direto do Node.js em fonte de máquina de escrever, sem formatação, porque você declarou text/plain. E o curl -i devolve HTTP/1.1 200 OK seguido de Content-Type: text/plain, os dois cabeçalhos que você escreveu à mão no código. Repare no que não está na pasta: nenhum node_modules, nenhum package.json, nenhum framework. Um servidor HTTP de verdade cabe em doze linhas da biblioteca que já veio instalada.

Se o terminal cuspir Error: listen EADDRINUSE, outro programa já ocupa a porta 3000. Troque o 3000 por 3001 no arquivo e rode de novo.

O que Node.js não é

A confusão mais comum é tratar Node.js como uma linguagem de programação, ao lado de Python e Java, em lista de requisito de vaga e em ementa de curso. Node.js é um runtime. A linguagem que você escreve dentro dele se chama JavaScript, a mesma do navegador, com o mesmo const, o mesmo for e a mesma Promise.

A distinção tem consequência prática. Quando você procurar como fazer algo, a resposta de sintaxe está na documentação do JavaScript, e a resposta de acesso a arquivo, porta ou processo está na documentação do Node.js. Quem confunde os dois passa horas procurando fs.readFile em material de front end, onde ele nunca vai estar.

Node.js também não é framework. Express, Fastify e NestJS são frameworks que rodam em cima dele, e nenhum deles apareceu no hello world acima.

Fontes

Node.js, Introduction to Node.js, de onde saiu o exemplo do servidor HTTP usado aqui, com createServer, 127.0.0.1 e porta 3000. Conferida em 15/08/2026.
Node.js API, módulo HTTP, referência de createServer, setHeader, statusCode e listen. Conferida em 15/08/2026.
Node.js, página oficial de download, de onde vieram os números de versão citados no passo 1. Conferida em 15/08/2026.
Node.js, calendário de releases, que separa as linhas Current, Active LTS e Maintenance. Conferida em 15/08/2026.

O hello world desta página foi executado em 15/08/2026, numa máquina Linux com Node.js v22.23.0. O comando node server.js imprimiu Servidor no ar em http://127.0.0.1:3000/, e curl -i http://127.0.0.1:3000/ devolveu HTTP/1.1 200 OK, Content-Type: text/plain, Content-Length: 31 e o corpo Olá, mundo, direto do Node.js. A pasta tinha um único arquivo. O EADDRINUSE descrito acima também apareceu de verdade, quando uma execução anterior ficou segurando a porta.

Para continuar

Se o JavaScript ainda estiver escorregadio, volte para JavaScript antes de seguir, porque o Node.js não ensina a linguagem, ele só executa. Se quiser comparar o mesmo servidor em outra linguagem de back end, Python resolve com uma biblioteca embutida parecida. O mapa com as outras dezenove tecnologias está no hub da stack web.

// conteúdo exclusivo

O curso desta trilha está em preparação. A lista paga menos.

Os tutoriais daqui continuam gratuitos. O que está a caminho é um curso pago que transforma esse mapa em formação guiada, na ordem certa e com projeto. Deixe seu e-mail: você recebe os estudos novos gratuitos e, no lançamento, o desconto de quem entrou na lista primeiro.