Tutorial de Node.js para iniciantes: de zero a seu primeiro aplicativo

Início » Python » Tutorial de Node.js para iniciantes: de zero a seu primeiro aplicativo

Se você é seu primeiro contato com Node.js, aqui você tem um guia pensado para começar com o bem: abordaremos o mais básico para um fluxo de trabalho real, com exemplos práticos e explicações claras. Você foi acompanhado do mítico Hola Mundo até lançar um aplicativo web com Express, passando por módulos de sistema, npm e a abordagem assíncrona que faz tão especial no ecossistema de Node.

Além de orientarte con requisitos anteriores, configuração em Visual Studio Code e primeiros projetos, veremos como organizar um servidor HTTP, inserir petições, gerenciar drivers, trabalhar com dados POST sem bloquear o arquivo e entender a filosofia orientada a eventos. Tudo com uma língua próxima, sem rodeios, e com o toque necessário para que não te furem.

Requisitos anteriores e o que esperar do Node.js

Você precisará de alguns conhecimentos básicos de JavaScript (tipos, variáveis, funções, objetos) e ganhos de teste de coisas com o console. Node.js é um ambiente de execução de JavaScript fora do navegador, baseado em V8, com uma biblioteca padrão poderosa e um modelo de execução direcionado por eventos e não bloqueado. Isso permite gerenciar muitas conexões simultâneas sem criar um fio para cada solicitação.

Com Node pode servidores web, APIs REST, ferramentas de linha de comandos, aplicativos em tempo real (chat, notificações), integrações com bases de dados e até projetos IoT. Sua fortaleza está no manejo de E/S simultâneo, o que o torna ideal para tráfego alto e experiências interativas.

Baixe e instale

Baixe Node.js da web oficial em nodejs.org e instale-o para seu sistema operacional. No Windows, macOS ou Linux tendem a ser instalados e pacotes adequados. Após a instalação, confirme no terminal com: node -v y npm -v. npm é o gerenciador de pacotes do Node e você poderá instalar bibliotecas de terceiros de forma simples.

Seu primeiro contato: Hola Mundo com VS Code

Se você usa o Visual Studio Code, você pode abrir a pasta do projeto e lançar o terminal integrado com total comodidade. Crie uma pasta de trabalho e insira-a: mkdir HelloNode && cd HelloNode.

Agora abre essa pasta no VS Code com código.. Crie um arquivo chamado app.js e introduza algo fácil para arrancar: un mensaje por consola.

var msg = 'Hello World';
console.log(msg);

Para executá-lo, abra o terminal integrado no VS Code (Ver > Terminal, ou atalho Ctrl+`), e lanza node app.js. Verás o clássico resultado “Hello World” na consola; sim, sim, mas confirmo que tudo vai bem.

De zero a servidor: um servidor HTTP mínimo

Nó trae um módulo nativo chamado 'http' com o que você pode criar um servidor em ocasiões online. O coração é http.createServer, que recebe uma função de retorno de chamada que é executada cada vez que você faz uma petição.

var http = require('http');

http.createServer(function (request, response) {
  response.writeHead(200, {'Content-Type': 'text/html'});
  response.write('Hola Mundo');
  response.end();
}).listen(8888);

Arráncalo con node server.js e visite http://localhost:8888/. A magia do Node está em seu modelo voltado para eventos: passa uma função e o tempo de execução da “chamada de volta” (retorno de chamada) quando o evento ocorre (uma solicitação entrante).

Entendendo retornos de chamada, assincronia e fluxo de execução

Em JavaScript as funções são dos primeiros cidadãos: você pode passar como argumentos, devolver e armazenar variáveis. Este padrão se conecta ao grupo de eventos do Node: seu código registra funções que são executadas quando ocorrem sucessos (por exemplo, você recebe uma solicitação HTTP).

É crucial entender a diferença entre operações bloqueantes e não bloqueadoras. Se alguma coisa ocupar a CPU durante alguns segundos (por exemplo, um botão de espera), o processo será interrompido e todas as solicitações serão atendidas. Em Node, trabalho sempre que posso com E/S assíncrona e retornos de chamada ou promessas para evitar o bloqueio do hilo.

Design modular: servidor, roteador e gerenciadores

Separar responsabilidades você ajudará a escalar o projeto: um módulo para o servidor HTTP, outro para o roteador e outros para os drivers (manipuladores de solicitações). Pode expor funções com exports e requerer módulos locais com require('./miModulo').

Uma estrutura típica poderia ser: index.js como ponto de entrada, servidor.js com o servidor HTTP, roteador.js para decidir qual função mandar cada rota e requestHandlers.js com a lógica de cada endpoint. Esta organização mantém o código legível e fácil de verificar.

Extraindo a rota e enrutando

O objeto solicitado tem o URL solicitado. O módulo nativo url permite extraer el pathname e, se houver falta, a consulta. Com isso, o roteador poderá decidir qual driver será executado.

var url = require('url');

function onRequest(request, response) {
  var pathname = url.parse(request.url).pathname;
  // route(pathname) ...
}

O roteador recebe o mapa de rutas a functions (um objeto onde cada chave é uma rota, e o valor, o manipulador), junto com o nome do caminho, e verifique se há uma função associada. Si existe, la ejecuta; se não, devolva um 404.

Fazendo com que o manipulador responda (o padrão correto)

Uma tentação habitual isso faz com que o driver retorne uma string e que o servidor a escreva. Mas isso falha quando o manipulador precisa fazer algo assíncrono (como ler um disco ou executar um comando). A solução realmente é injetar o objeto resposta até o manipulador e o manipulador próprio escreve a resposta quando a tenga (por exemplo, dentro do retorno de chamada de uma função assíncrona).

// router.js
function route(handle, pathname, response) {
  if (typeof handle[pathname] === 'function') {
    handle[pathname](response);
  } else {
    response.writeHead(404, {'Content-Type': 'text/html'});
    response.write('404 No Encontrado');
    response.end();
  }
}

Esta abordagem permite responder apenas quando a E/S asíncrona concluir, sem bloquear o processo e forçar a devolução dos dados antes do tempo.

Express: crie um aplicativo web em minutos

Express é uma estrutura minimalista para Node.js que facilita o gerenciamento de rotas, visualizações, middleware e HTTP russo. Com seu gerador você pode criar a estrutura de um projeto em segundos, com pastas para rotas, vistas e recursos estáticos.

1. Crie uma pasta para seus projetos: mkdir ExpressProjects && cd ExpressProjects.
2. Genera una plantilla: npx express-generator HelloWorld --view=pug Crie o aplicativo com motor de vista Pug.
3. Abrir no VS Code com code . y revisa la estructura: caixa (arranque), público (JS/CSS/imagens), rotas (controladores de rutas), visualizações (plantillas), aplicativo js (configuração), package.json (scripts e dependências).
4. Instalar dependências com npm install en la carpeta del proyecto.
5. Iniciar o aplicativo. Por exemplo, com depuração: npx cross-env DEBUG=HelloWorld:* npm start.
6. Aberto http://localhost:3000. Experimente mudar a vista principal: Em views/index.pug, substitui o título por h1 "Hello World!" e recarregue.

Expresso incorpora o necessário para Gerenciar GET, POST, PUT e DELETE, use middleware, use estáticos, renderize vistas e estruture um aplicativo de várias páginas com menos fricção.

npm e módulos incorporados do Node

npm é o gerenciador de pacotes do Node e você permite instalar bibliotecas de terceiros. Por exemplo, para adicionar Express: npm install express. Então você pode require('express') e use-o em seu código. Esta flexibilidade é chave para crescer com seu projeto.

Além disso, Node inclui módulos nativos para tarefas comuns: fs (arquivos), http/https (servidores), path (rutas), os (dados do sistema), url (análise de URL) e muito mais. Você pode importá-los com require() sem instalar nada.

Testando um módulo nativo: informações do sistema

O módulo 'os' fornece dados do sistema operacional. Abra o console e entre no REPL do Node com node para testar funções rapidamente sem criar arquivos.

1. Escrever os.platform() para saber a plataforma (win32, linux, darwin…). Confirmarás el SO active diretamente.
2. Com os.arch() você obterá a arquitetura (x64, arm64…). Útil para binários ou builds.
3. Usar os.cpus() para ver os núcleos disponíveis. Ideal para equilibrar carga com clusters ou processos filhos.
4. Sal del REPL con .exit ou pressionando Ctrl+C das vezes. Rápido e sem resíduos.

Biblioteca de terceiros útil no dia a dia

El ecosistema npm es enorme. Algumas das utilidades populares: afiado (tratamento de imagens e compressão), Kit PDF (geração de PDF), validador.js (validação de correntes), imagem em y UglifyJS (minificação), spritesmith (sprites), Winston (registro) y comandante.js (CLI). Instálalas con npm install <paquete> quando você precisar deles.

Como executar o código Node.js do arquivo

Guarde seu código em um arquivo, por exemplo app.js, e ejecútalo con node app.js no terminal. Isso inicia seu programa e você verá os resultados no console ou, se abrir um servidor, no seu navegador.

Del REPL para o aplicativo real: fluxo completo

Testar no REPL é perfeito para pequenas funções, mas quando seu código for criado, você poderá passar para arquivos, organizar módulos e adicionar scripts de npm. De esta forma podrás automatizar tarefas com npm run e documentar os comandos de início em package.json.

Manejando dados POST sem bloquear

Quando um usuário envia um formulário, o corpo da petição pode gerar vários troços. No servidor (callback de createServer) ouvintes de añade data y end para ir acumulando o conteúdo e processá-lo até o final. Indica também a codificação, por exemplo UTF-8, para manipulá-la corretamente.

request.setEncoding('utf8');
var postBody = '';
request.addListener('data', function(chunk) {
  postBody += chunk;
});
request.addListener('end', function() {
  // route(handle, pathname, response, postBody)
});

Se você precisar de campos extras individuais, usa o módulo 'querystring' para analisar o corpo quando você chega como application/x-www-form-urlencoded: querystring.parse(postBody).text, Por exemplo.

Operações caras e executadas sem bloqueio

Para executar comandos do sistema sem impedir o servidor, utilize child_process.exec e respondo no retorno de chamada. Você pode adicionar opções como timeout o maxBuffer para controlar comandos pesados. El patrón é sempre o mesmo: nada de bloquear, e responde quando há dados.

var exec = require('child_process').exec;

function handler(response) {
  exec('ls -lah', function(error, stdout, stderr) {
    response.writeHead(200, {'Content-Type': 'text/plain'});
    response.write(stdout);
    response.end();
  });
}

Se o comando for alterado para algo mais exigente, o resto das rotas seguirá respondendo com normalidade sempre que não há trabalho sincrônico caro no hilo principal.

Subidas de fichas: abordagem e ferramentas

Para manejar uploads multiparte (imagens ou outros arquivos) o mais prático é recorrer a um pacote especializado. Módulos como formidável facilitan parsear formularios multipart/form-data, acesse os arquivos temporais e mova-os para seu destino. A ideia é a mesma: retornos de chamada/promessas e trabalhe de forma segura com streams.

Embora a implementação completa tenha escapado aos primeiros passos, o importante é que o upload seja integrado em seu fluxo: servidor que recebe o formulário, roteador que dirige a rota de subida, e treinador que valida, guarda e responde com o resultado (por exemplo, mostrando a imagem).

Estrutura de vistas e conteúdo dinâmico

Se você optar por Express com Pug ou outro motor, o driver passa os dados para a vista e os renderiza. Para um formulário simples com uma área de texto enviada por POST e uma rota que a mostra, basta com os manipuladores: um que sirva o formulário e outro que processe e devolva o conteúdo recebido.

Boas práticas organizacionais

Evita archivos monolíticos. Divida em módulos, nombra funções com verbos que expressam ações (por exemplo, iniciar, carregar, listas), e desacople com a injeção de dependências quando tengo sentido (passando funções ou mapas de rotas para o servidor e para o roteador). Manter as capas leves permitirá que você cresça sem dor.

O que você pode construir com Node.js

Seu modelo orientado a eventos e sem bloqueio Isso é especialmente bom para: servidores web, APIs REST, aplicativos em tempo real (chat, dashboards), bots e CLIs, integrações com bases de dados, colunas de trabalho e controle de hardware. A facilidade de gerenciamento de websockets e streaming é uma escolha natural para experiências interativas.

• Servidores e sites com plantas ou SSR.
• APIs REST preparados para alto tráfego.
• Tempo real com soquetes para bate-papo, notificações ou jogos.
• ferramentas de linha de comando para automatizar tarefas.
• Processos com fichas e bases de dados, colas e oleodutos.
• IoT e hardware com livrarias específicas.

Ferramentas de aprendizagem e prática

Existem ambientes interativos que exibem código e saída lado a lado, ideais para entender exemplos rápidos. Então, você pode progredir sem criar contas: documentar, copiar exemplos e executar localmente com seu terminal é mais do que suficiente no início.

Código do Visual Studio: produtividade sem saída do editor

O terminal integrado, o purificador e as extensões O VS Code faz com que você trabalhe com o Node muito cómodo. Desde “Ver > Terminal” você pode abrir shells, alterar o padrão e executar node o npm run sem abandonar o editor. Además, configurar launch.json você poderá depurar passo a passo.

Apuntes de versão e estabilidade

Muitas guias clássicas foram testadas com versões antigas de Node, mas os conceitos são mantidos em vigor: callbacks, módulos nativos, assincronia, enrutado e separação de responsabilidades. Hoje trabalhamos com versões atuais, mais rápidas e seguras, e com um ecossistema npm ainda mais rico.

Descargas e recursos adicionais

Você pode ampliar o estúdio com documentação, PDFs e tutoriais. Revise sempre o site oficial do Node para novidades e download, e identifique fontes didáticas que incluem exercícios, testes e desafios para afiançar conhecimentos à medida que avança.

Se você procurar material complementar, encontrará guias introdutórios e referências práticas com exemplos, bem como links de download quando necessário. Mantenha seu foco na prática: ler está bem; executar, romper coisas e arreglarlas, melhor.

Exemplo completo: mini app com roteador e manipuladores

Juntando piezas. Imagine um projeto com index.js que arranca el servidor, servidor.js com HTTP e análise de POST, roteador.js que decide qual função executar e requestHandlers.js con dos rutas: um que mostra um formulário e outro que indica o texto enviado.

// index.js
var server = require('./server');
var router = require('./router');
var handlers = require('./requestHandlers');

var handle = {};
handle['/'] = handlers.iniciar;
handle['/iniciar'] = handlers.iniciar;
handle['/subir'] = handlers.subir;

server.iniciar(router.route, handle);

// server.js
var http = require('http');
var url = require('url');

function iniciar(route, handle) {
  function onRequest(request, response) {
    var postData = '';
    var pathname = url.parse(request.url).pathname;

    request.setEncoding('utf8');
    request.addListener('data', function(chunk) { postData += chunk; });
    request.addListener('end', function() {
      route(handle, pathname, response, postData);
    });
  }

  http.createServer(onRequest).listen(8888);
}

exports.iniciar = iniciar;

// router.js
function route(handle, pathname, response, postData) {
  if (typeof handle[pathname] === 'function') {
    handle[pathname](response, postData);
  } else {
    response.writeHead(404, {'Content-Type': 'text/html'});
    response.end('404 No Encontrado');
  }
}

exports.route = route;

// requestHandlers.js
var querystring = require('querystring');

function iniciar(response) {
  var body = '<html>'+
    '<head><meta charset=\'UTF-8\' /></head>'+
    '<body>'+
    '<form action=\'/subir\' method=\'post\'>'+
    '<textarea name=\'text\' rows=\'10\' cols=\'40\'></textarea>'+
    '<input type=\'submit\' value=\'Enviar\' />'+
    '</form>'+
    '</body></html>';

  response.writeHead(200, {'Content-Type': 'text/html'});
  response.end(body);
}

function subir(response, postData) {
  var text = querystring.parse(postData).text || '';
  response.writeHead(200, {'Content-Type': 'text/html'});
  response.end('Tu enviaste: ' + text);
}

exports.iniciar = iniciar;
exports.subir = subir;

Com este esqueleto mínimo você tem um servidor funcional e não bloqueado, com rotas e drivers separados, preparados para criar vistas, uploads ou integração com bases de dados.

A chave do Node está pensando em “ações”: passar funções, criar dependências quando for convocar e manter pequenos blocos de responsabilidade. Assim, seu aplicativo será mais fácil de manter e adaptar conforme aumentar sua complexidade.

Tudo o que você viu foi uma base sólida: desde instalar o Node e executar seu primeiro script, passando pelo VS Code, um servidor HTTP nativo, enrutado próprio, Express, npm, módulos nativos, REPL, assincronia sem bloqueios e gerenciamento de formulários POST. Com prática e pequenas iterações, você poderá construir projetos cada vez mais completos sem perder clareza no código.