Aprender Node.js pode parecer desafiador no início, mas com as ferramentas e recursos certos, você pode dominar essa poderosa plataforma de desenvolvimento rapidamente. Neste guia, exploraremos desde os fundamentos até técnicas avançadas para te ajudar a se tornar um expert.
Instalando Node.js
Para aprender Node.js é essencial começar do básico, e isso inclui a instalação. Acesse o site oficial de Node.js (https://nodejs.org/) e faça o download da versão LTS (Long Term Support). Ela é recomendada para a maioria dos usuários e garante maior estabilidade.
Após o download, siga os passos de instalação típicos de qualquer programa. No Windows, você precisará apenas executar o arquivo .exe e seguir as instruções. No macOS, você deve usar o instalador .pkg. Para Linux, utilize os seguintes comandos:
sudo apt update sudo apt install nodejs sudo apt install npm
Criando seu primeiro projeto Node.js
Com o Node.js instalado, é hora de criar seu primeiro projeto. Inicialmente, crie uma nova pasta para o seu projeto. Por exemplo, você pode chamá-la de meu-projeto-node:
mkdir meu-projeto-node cd meu-projeto-node
Dentro da pasta do projeto, inicialize um novo projeto Node.js utilizando o comando npm init. Esse comando criará um arquivo package.json que contém informações sobre o seu projeto e suas dependências. Siga as instruções e preencha as informações necessárias.
Agora, crie um arquivo chamado index.js e abra-o em seu editor de código preferido. Esse será o arquivo principal do seu projeto.
Escrevendo suas primeiras linhas de código
No arquivo index.js, comece escrevendo um simples console.log para garantir que tudo está funcionando corretamente:
console.log('Olá, mundo!');
Para executar o código, volte ao terminal e digite:
node index.js
Se tudo estiver configurado corretamente, você verá a mensagem “Olá, mundo!” no terminal. Parabéns, você escreveu suas primeiras linhas de código em Node.js!
Trabalhando com Módulos
Node.js é construído com uma arquitetura modular, o que significa que você pode dividir seu código em diferentes arquivos e importar módulos conforme a necessidade. Vamos criar um módulo simples.
Crie um novo arquivo chamado mensagem.js e escreva o seguinte código:
function mensagem() {
return 'Olá, este é um módulo!';
}
module.exports = mensagem;
Agora, no arquivo index.js, importe e utilize o módulo mensagem:
const mensagem = require('./mensagem');
console.log(mensagem());
Execute o código novamente com node index.js e você verá a mensagem retornada pelo módulo.
Utilizando pacotes de terceiros
O Node.js possui um enorme ecossistema de pacotes de terceiros que podem facilitar seu trabalho. Um dos mais populares é o express, um framework para construção de servidores web. Vamos instalá-lo e utilizá-lo em nosso projeto.
No terminal, dentro da pasta do seu projeto, digite:
npm install express
Crie um novo arquivo chamado server.js e adicione o seguinte código:
const express = require('express');
const app = express();
app.get('/', (req, res) => {
res.send('Bem-vindo ao seu primeiro servidor com Express!');
});
app.listen(3000, () => {
console.log('Servidor rodando na porta 3000');
});
Para executar o servidor, digite no terminal:
node server.js
Abra seu navegador e acesse http://localhost:3000. Você verá a mensagem “Bem-vindo ao seu primeiro servidor com Express!”.
Manipulando Rotas e Middlewares
Express permite criar rotas e middlewares, tornando mais fácil a criação de aplicações web complexas. Vamos adicionar rotas adicionais e um middleware simples.
No arquivo server.js, adicione:
app.use((req, res, next) => {
console.log(`Requisição recebida: ${req.method} ${req.url}`);
next();
});
app.get('/sobre', (req, res) => {
res.send('Essa é a página sobre.');
});
Esse middleware irá logar cada requisição recebida. Agora, ao acessar http://localhost:3000/sobre, você verá a nova mensagem.
Trabalhando com o Body Parser
Para manejar dados enviados via POST, instale o pacote body-parser:
npm install body-parser
No arquivo server.js, adicione:
const bodyParser = require('body-parser');
app.use(bodyParser.urlencoded({ extended: false }));
app.use(bodyParser.json());
app.post('/dados', (req, res) => {
console.log(req.body);
res.send('Dados recebidos com sucesso');
});
Isso permitirá capturar e manipular dados enviados em requisições POST.
Conectando com um Banco de Dados
Conectar uma aplicação Node.js a um banco de dados é um passo necessário para muitos projetos. Usaremos o MongoDB, um banco de dados NoSQL, e o mongoose, uma biblioteca que facilita a interação com ele. Instale com:
npm install mongoose
Adicione ao seu código:
const mongoose = require('mongoose');
mongoose.connect('mongodb://localhost:27017/meuBancoDeDados', {
useNewUrlParser: true,
useUnifiedTopology: true
}, () => console.log('Conectado ao MongoDB'));
// Definindo um esquema e modelo
const esquemaUsuario = new mongoose.Schema({
nome: String,
email: String,
senha: String
});
const Usuario = mongoose.model('Usuario', esquemaUsuario);
app.post('/registrar', async (req, res) => {
const { nome, email, senha } = req.body;
const novoUsuario = new Usuario({ nome, email, senha });
await novoUsuario.save();
res.send('Usuário registrado com sucesso');
});
Essa configuração permite armazenar e recuperar dados diretamente do MongoDB.
Node.js com Promises e Async/Await
Node.js é assíncrono por natureza. Trabalhar com promises e async/await é crucial. Veja como lidar com uma situação assíncrona:
// Usando Promises
function tarefaDemorada(ms) {
return new Promise(resolve => setTimeout(resolve, ms));
}
tarefaDemorada(2000).then(() => console.log('Tarefa completada'));
// Usando Async/Await
async function executarTarefa() {
await tarefaDemorada(2000);
console.log('Tarefa completada com async/await');
}
executarTarefa();
Conclusão
Neste post abordamos o início dos estudos em Node.js, desde a instalação até a criação de um servidor web simples e conexão com banco de dados. Continue explorando e praticando para consolidar seus conhecimentos.
