Fundamentos básicos do Node.js e configuração do ambiente de desenvolvimento
Esta aula foi criada especialmente para iniciantes absolutos. Mesmo se você nunca programou antes, vamos explicar cada conceito do zero, passo a passo.
Não tenha medo de errar! Programação é como aprender a andar de bicicleta - você vai cair algumas vezes, mas logo estará pedalando com confiança! 🚴♂️
Antes de começar a programar, você precisa ter algumas ferramentas instaladas no seu computador. É como preparar a cozinha antes de cozinhar - você precisa dos utensílios certos!
O que é: Um programa especial para escrever código de forma organizada, com cores e recursos que facilitam a programação.
Sublime Text, Atom, Notepad++ (mas recomendamos o VS Code)
O que é: Uma interface de texto onde você digita comandos para o computador executar. É como "conversar" com o computador usando texto.
PowerShell ou Prompt de Comando (já vem instalado)
Como abrir: Pressione Win + R, digite "powershell" e aperte Enter
Terminal (já vem instalado)
Como abrir: Cmd + Espaço, digite "terminal" e aperte Enter
Terminal (já vem instalado)
Como abrir: Ctrl + Alt + T ou procure por "Terminal" no menu
Mesmo se você nunca viu estes conceitos antes, vamos explicar cada um durante a aula. Esta lista é só para você saber o que vamos abordar!
"Caixinhas" para guardar informações
let nome = "João";
Explicação: Como uma etiqueta em uma caixa - você guarda algo e dá um nome para encontrar depois
"Máquinas" que fazem tarefas específicas
function somar(a, b) { }
Explicação: Como uma máquina de café - você coloca ingredientes e ela faz o café
Repetir ações várias vezes
for (let i = 0; i < 10; i++) { }
Explicação: Como fazer flexões - repetir a mesma ação um número específico de vezes
Marque cada item conforme você for completando:
💪 Vamos começar esta jornada incrível juntos!
Bem-vindo à primeira aula do nosso curso de Backend com Node.js! Se você chegou até aqui, provavelmente já sabe um pouco de JavaScript e quer aprender como criar aplicações que rodam no servidor.
Imagine um restaurante: o frontend é a parte que os clientes veem (o salão, o cardápio, os garçons), enquanto o backend é a cozinha - onde a comida é realmente preparada, onde ficam os ingredientes e onde toda a lógica de funcionamento acontece.
No mundo da programação, o backend é responsável por processar dados, conectar com bancos de dados, autenticar usuários, enviar emails, e muito mais!
Antes do Node.js, se você soubesse JavaScript, só podia trabalhar no frontend. Para o backend, precisava aprender outras linguagens como PHP, Python, Java ou C#.
O Node.js mudou isso! Agora você pode usar JavaScript tanto no frontend quanto no backend, o que significa menos linguagens para aprender e mais produtividade!
Node.js é um ambiente de execução que permite rodar código JavaScript fora do navegador, diretamente no seu computador ou servidor.
Tradicionalmente, JavaScript só funcionava dentro de navegadores como Chrome, Firefox ou Safari. O Node.js pegou o motor V8 (o mesmo que o Chrome usa para executar JavaScript) e o "libertou" do navegador!
O que significa: Pode fazer várias coisas ao mesmo tempo sem "travar". Enquanto espera uma resposta do banco de dados, pode processar outras requisições.
Analogia: Como um garçom que anota vários pedidos e não fica parado esperando a cozinha terminar um prato antes de anotar o próximo.
O que significa: Usa apenas uma "linha de execução" principal, mas é muito eficiente graças ao Event Loop (vamos ver isso em detalhes mais tarde).
Vantagem: Consome menos memória que linguagens que criam uma thread para cada usuário.
O que é: NPM (Node Package Manager) é como uma "loja de aplicativos" para desenvolvedores, com mais de 1 milhão de pacotes gratuitos!
Exemplo: Precisa enviar emails? Tem pacote. Conectar com banco de dados? Tem pacote. Processar imagens? Tem pacote!
O que significa: O mesmo código Node.js roda em Windows, macOS e Linux sem modificações.
Vantagem: Você desenvolve uma vez e pode rodar em qualquer servidor!
Node.js = JavaScript + Superpoderes para rodar no servidor!
Ryan Dahl cria o Node.js para resolver problemas de I/O não-bloqueante
Isaac Schlueter cria o Node Package Manager
Criação da fundação para governança do projeto
Milhões de pacotes no NPM e adoção massiva na indústria
O Event Loop é o "coração" do Node.js. É o mecanismo que permite que o Node.js faça várias coisas ao mesmo tempo, mesmo usando apenas uma "linha de execução" principal.
Imagine uma loja com apenas um funcionário (single-threaded), mas que é super eficiente:
O funcionário nunca fica parado esperando! Isso é o Event Loop em ação.
O que é: A "mesa de trabalho" onde o código é executado
Como funciona: Executa uma função por vez, de cima para baixo
O que é: A "fila de espera" para funções que terminaram operações assíncronas
Como funciona: Aguarda sua vez para ser executada
O que é: O "gerente" que coordena tudo
Como funciona: Verifica se a Call Stack está vazia e move callbacks da fila
O que é: "Funcionários extras" para tarefas pesadas
Como funciona: Executa operações como leitura de arquivos em paralelo
// 1. Esta linha executa IMEDIATAMENTE
console.log('🚀 Início do programa');
// 2. setTimeout é ASSÍNCRONO - vai para Thread Pool
// Mesmo com 0ms, não executa imediatamente!
setTimeout(() => {
console.log('⏰ Timeout executado após 0ms');
}, 0);
// 3. Esta linha executa IMEDIATAMENTE (é síncrona)
console.log('📝 Meio do programa');
// 4. Outra operação assíncrona
setTimeout(() => {
console.log('⏰ Segundo timeout executado');
}, 100);
// 5. Esta linha executa IMEDIATAMENTE
console.log('🏁 Fim do programa');
🚀 Início do programa
📝 Meio do programa
🏁 Fim do programa
⏰ Timeout executado após 0ms
⏰ Segundo timeout executado
1-3-5: Código síncrono executa primeiro (Call Stack)
2: setTimeout vai para Thread Pool, mesmo com 0ms
4: Segundo setTimeout também vai para Thread Pool
Depois: Event Loop move callbacks da fila quando Call Stack está vazia
Seu servidor pode atender milhares de usuários simultaneamente sem "travar" esperando operações lentas.
Enquanto um usuário espera dados do banco, o servidor pode processar requisições de outros usuários.
Event Loop = Node.js fazendo malabarismo com tarefas para nunca ficar parado! 🤹♂️
✅ O que você vai precisar:
💡 Dica: Sempre escolha a versão LTS (Long Term Support) - é a mais estável!
.msi⚠️ Importante: Se aparecer uma janela pedindo permissão de administrador, clique "Sim".
.pkgSe você tem Homebrew instalado:
brew install node
sudo apt update
sudo apt install nodejs npm
sudo yum install nodejs npm
cmd e pressione Enter
1. Verificar se o Node.js foi instalado:
node --version
Deve aparecer algo como: v20.10.0
2. Verificar se o NPM foi instalado:
npm --version
Deve aparecer algo como: 10.2.3
Você verá números de versão aparecendo no terminal. Parabéns! O Node.js está instalado e funcionando!
Erro comum: "'node' não é reconhecido como comando"
Solução: Feche e abra o terminal novamente, ou reinicie o computador
Se ainda não funcionar: Reinstale o Node.js marcando a opção "Add to PATH"
O que vamos fazer: Criar nosso primeiro programa em Node.js! É tradição na programação começar com um "Hello World" - um programa simples que apenas exibe uma mensagem.
Um script é simplesmente um arquivo de texto que contém código que o computador pode executar.
No caso do Node.js, nossos scripts têm a extensão .js (JavaScript).
Analogia: Pense no script como uma receita de bolo. Você escreve os passos (código) e o Node.js segue essas instruções para "fazer o bolo" (executar o programa).
Importante: O arquivo DEVE ter a extensão .js. Se você não conseguir ver as extensões dos arquivos, procure nas configurações do seu sistema operacional por "mostrar extensões de arquivo".
Agora vamos escrever nosso primeiro código. Abra o arquivo hello.js em qualquer editor de texto e digite exatamente isto:
// Este é um comentário - o Node.js ignora esta linha
// Comentários servem para explicar o que o código faz
// Esta linha exibe uma mensagem no terminal
console.log("Olá, mundo! Este é meu primeiro script Node.js!");
// Vamos exibir mais algumas coisas interessantes
console.log("Parabéns! Você está programando!");
console.log("Node.js versão:", process.version);
console.log("Sistema operacional:", process.platform);
// Este é um comentário...
Comentários: Linhas que começam com // são ignoradas pelo Node.js.
Servem para explicar o código para outros programadores (ou para você mesmo no futuro!).
console.log("Olá, mundo!...");
console.log(): É como um "print" - exibe texto no terminal. O texto entre aspas será mostrado exatamente como está escrito.
process.version
process.version: Uma variável especial do Node.js que contém a versão instalada.
O process é um objeto global com informações do sistema.
process.platform
process.platform: Mostra qual sistema operacional você está usando ("win32" para Windows, "darwin" para macOS, "linux" para Linux).
Dica: Digite o código exatamente como mostrado, incluindo os pontos e vírgulas (;) no final de cada linha. Eles são importantes em JavaScript!
Agora vem a parte emocionante: Vamos executar nosso código e ver ele funcionando!
Opção 1: Win + R → digite "cmd" → Enter
Opção 2: Win + X → "Prompt de Comando"
Opção 3: Pesquisar "cmd" no menu Iniciar
Opção 1: Cmd + Space → "Terminal" → Enter
Opção 2: Aplicações → Utilitários → Terminal
Opção 3: Launchpad → Terminal
Opção 1: Ctrl + Alt + T
Opção 2: Menu → Terminal
Opção 3: Pesquisar "terminal"
O terminal sempre "está" em alguma pasta. Precisamos ir até a pasta onde salvamos nosso arquivo hello.js.
cd nome-da-pasta
Entra em uma pasta
cd ..
Volta uma pasta
dir (Windows) ou ls (Mac/Linux)
Lista arquivos da pasta atual
Se você salvou o arquivo em "Documentos/meus-scripts-nodejs", digite:
cd Documents\meus-scripts-nodejs
cd Documents/meus-scripts-nodejs
Agora que estamos na pasta certa, vamos executar nosso script com o comando mágico:
node hello.js
node
Chama o programa Node.js
hello.js
Nome do arquivo que queremos executar
Olá, mundo! Este é meu primeiro script Node.js!
Parabéns! Você está programando!
Node.js versão: v20.10.0
Sistema operacional: win32
🎉 Parabéns! Você acabou de executar seu primeiro programa Node.js!
// Este é um comentário
Linhas que começam com // são comentários. O Node.js as ignora completamente.
console.log('Hello, World!');
console.log() é uma função que exibe texto no terminal. O texto deve estar entre aspas.
process.version
process é um objeto global que contém informações sobre o programa atual.
;
O ponto e vírgula marca o fim de uma instrução em JavaScript.
Você precisa "navegar" até a pasta onde salvou o arquivo hello.js. Use o comando cd (change directory = mudar diretório):
# Exemplo: se você salvou em Documentos/meus-scripts-nodejs
# Windows:
cd "C:\Users\SeuNome\Documents\meus-scripts-nodejs"
# macOS/Linux:
cd ~/Documents/meus-scripts-nodejs
# Para verificar se está na pasta certa, liste os arquivos:
# Windows:
dir
# macOS/Linux:
ls
Dica: Se você ver o arquivo "hello.js" listado, significa que está na pasta correta!
Agora digite o comando mágico que vai executar seu primeiro programa Node.js:
node hello.js
Se tudo deu certo, você deve ver algo assim no terminal:
Hello, World!
Bem-vindo ao Node.js!
Versão do Node.js: v22.17.0
Plataforma: win32
🎊 Parabéns! Você acabou de executar seu primeiro programa Node.js! Você agora é oficialmente um desenvolvedor backend iniciante!
Causa: Node.js não está instalado ou não está no PATH do sistema.
Solução: Volte à seção de instalação e reinstale o Node.js. Reinicie o terminal após a instalação.
Causa: Você não está na pasta correta ou o arquivo não existe.
Solução: Use dir (Windows) ou ls (macOS/Linux) para listar arquivos. Navegue até a pasta correta com cd.
Causa: Erro de digitação no código.
Solução: Verifique se você digitou o código exatamente como mostrado, incluindo aspas e ponto e vírgula.
O que é o NPM: É como uma "loja de aplicativos" para programadores! Contém milhões de bibliotecas (pedaços de código) prontas para usar em seus projetos.
O NPM (Node Package Manager) é o gerenciador de pacotes do Node.js. Imagine que você está construindo uma casa - em vez de fazer cada tijolo do zero, você pode comprar tijolos prontos. O NPM é a "loja de tijolos" para programadores!
Pacotes são pedaços de código que outros programadores criaram e compartilharam. Por exemplo: um pacote para trabalhar com datas, outro para enviar emails, etc.
Mais de 2 milhões de pacotes! É o maior repositório de software do mundo. Praticamente qualquer funcionalidade que você imaginar, alguém já criou.
Analogia: Se programar fosse cozinhar, o NPM seria um supermercado gigante onde você pode comprar ingredientes prontos (pacotes) em vez de plantar e colher tudo do zero!
O package.json é como a "certidão de nascimento" do seu projeto.
Ele contém informações importantes como o nome do projeto, versão, e quais pacotes ele precisa para funcionar.
Primeiro, vamos criar uma pasta para nosso projeto NPM. Abra o terminal e digite:
mkdir meu-primeiro-projeto-npm
cd meu-primeiro-projeto-npm
mkdir meu-primeiro-projeto-npm
cd meu-primeiro-projeto-npm
mkdir = "make directory" = criar pasta
cd = "change directory" = entrar na pasta
Agora vamos criar o arquivo package.json. Existem duas formas:
npm init
Este comando fará várias perguntas. Você pode pressionar Enter para aceitar as sugestões:
package name: (meu-primeiro-projeto-npm) ← Pressione Enter
version: (1.0.0) ← Pressione Enter
description: Meu primeiro projeto com NPM ← Digite isso
entry point: (index.js) ← Pressione Enter
test command: ← Pressione Enter
git repository: ← Pressione Enter
keywords: ← Pressione Enter
author: Seu Nome ← Digite seu nome
license: (ISC) ← Pressione Enter
npm init -y
O -y significa "yes" para tudo. Cria um package.json básico instantaneamente.
Após executar o comando, um arquivo package.json será criado. Vamos ver o que tem dentro:
type package.json
cat package.json
{
"name": "meu-primeiro-projeto-npm",
"version": "1.0.0",
"description": "Meu primeiro projeto com NPM",
"main": "index.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
},
"author": "Seu Nome",
"license": "ISC"
}
npm install nome-do-pacote
Exemplo: npm install colors (pacote para colorir texto no terminal)
npm install
Instala todos os pacotes listados no package.json
npm install -g nome-do-pacote
O -g instala o pacote para uso em qualquer lugar do computador
npm list
npm --version
npm search nome
npm info nome-do-pacote
npm uninstall nome-do-pacote
Remove o pacote do projeto e atualiza o package.json
O package.json é como a "certidão de nascimento" do seu projeto.
Ele contém informações importantes como:
Este método faz perguntas e você responde. É ótimo para aprender!
# Abra o terminal na pasta do seu projeto e digite:
npm init
💡 Valores entre parênteses são sugestões. Pressione Enter para aceitar ou digite algo diferente.
Este método cria o package.json automaticamente com valores padrão:
# Cria package.json com valores padrão (sem perguntas)
npm init -y
Após executar qualquer um dos comandos acima, você terá um arquivo package.json na sua pasta. Ele vai parecer com isto:
{
"name": "meu-primeiro-projeto",
"version": "1.0.0",
"description": "Meu primeiro projeto Node.js",
"main": "index.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
},
"author": "Seu Nome",
"license": "ISC"
}
npm install nome-do-pacote
# Exemplo prático:
npm install express
O que faz: Baixa e instala um pacote específico. O Express, por exemplo, é um framework para criar servidores web.
Onde fica: Cria uma pasta node_modules e adiciona o pacote ao package.json.
npm install
# Ou a versão abreviada:
npm i
O que faz: Lê o package.json e instala TODOS os pacotes listados nas dependências.
Quando usar: Quando você baixa um projeto de outra pessoa ou clona do GitHub.
# Executar o script "start"
npm start
# Executar qualquer script personalizado
npm run nome-do-script
# Exemplo:
npm run dev
O que faz: Executa comandos definidos na seção "scripts" do package.json.
Exemplo: Se você definir "start": "node app.js", o npm start vai executar node app.js.
# Ver todos os pacotes instalados
npm list
# Ver apenas os pacotes principais (sem sub-dependências)
npm list --depth=0
O que faz: Mostra uma lista de todos os pacotes instalados no seu projeto.
meu-projeto/
├── node_modules/ ← Pasta criada automaticamente (NUNCA edite!)
│ ├── express/ ← Pacotes instalados ficam aqui
│ ├── outro-pacote/
│ └── ...
├── package.json ← Arquivo que você criou
├── package-lock.json ← Criado automaticamente (não edite)
└── hello.js ← Seus arquivos de código
⚠️ IMPORTANTE: NUNCA edite ou delete a pasta node_modules manualmente!
Ela é gerenciada automaticamente pelo NPM. Se precisar "limpar", delete a pasta e execute npm install novamente.
# Criar uma nova pasta
mkdir minha-padaria-app
# Entrar na pasta
cd minha-padaria-app
# Criar package.json
npm init -y
# Instalar o pacote 'colors' para texto colorido
npm install colors
Crie um arquivo app.js:
// Importar o pacote 'colors'
const colors = require('colors');
// Usar o pacote para criar texto colorido
console.log('🍞 Bem-vindo à Padaria do João!'.rainbow);
console.log('Pães frescos todos os dias!'.green);
console.log('Horário: 6h às 18h'.blue);
node app.js
Você verá texto colorido no terminal! 🌈
Estes exercícios vão consolidar tudo que você aprendeu nesta aula. Cada exercício tem explicações detalhadas, código comentado linha por linha e seções de troubleshooting para te ajudar caso algo dê errado.
💡 Dica: Tente fazer sozinho primeiro, depois consulte a solução!
Nível: Iniciante | Tempo estimado: 10 minutos
os e process)Você vai criar um script que funciona como um "detector de sistema". Imagine que você é um técnico de informática e precisa saber rapidamente as características do computador onde está trabalhando. Seu script vai mostrar:
🖥️ === INFORMAÇÕES DO SISTEMA ===
💻 Sistema Operacional: Windows
🧠 Memória RAM Total: 16.00 GB
⚡ Processadores (CPUs): 8
⏰ Tempo Ligado: 2 horas, 34 minutos
👤 Usuário: João Silva
✅ Análise concluída com sucesso!
# Criar pasta
mkdir exercicio-sistema
# Entrar na pasta
cd exercicio-sistema
💡 Por que fazer isso? Organização! Cada exercício em sua própria pasta evita confusão.
Abra seu editor de código favorito (VS Code, Notepad++, etc.) e crie um arquivo chamado sistema.js
Agora vamos escrever o código. Vou explicar cada linha para você entender exatamente o que está acontecendo:
// ===== IMPORTANDO MÓDULOS =====
// Linha 1: Importar o módulo 'os' (Operating System)
// Este módulo nos dá acesso a informações do sistema operacional
const os = require('os');
// Linha 2: Importar o módulo 'process'
// Este módulo nos dá informações sobre o processo Node.js atual
const process = require('process');
// ===== COLETANDO INFORMAÇÕES =====
// Linha 3: Descobrir qual sistema operacional está rodando
// os.platform() retorna: 'win32' (Windows), 'darwin' (Mac), 'linux' (Linux)
const sistemaOperacional = os.platform();
// Linha 4: Converter o nome técnico para algo mais amigável
let nomeSistema;
if (sistemaOperacional === 'win32') {
nomeSistema = 'Windows';
} else if (sistemaOperacional === 'darwin') {
nomeSistema = 'macOS';
} else if (sistemaOperacional === 'linux') {
nomeSistema = 'Linux';
} else {
nomeSistema = 'Sistema Desconhecido';
}
// Linha 5: Descobrir quanta memória RAM o computador tem
// os.totalmem() retorna em bytes, então dividimos por 1024³ para ter GB
const memoriaBytes = os.totalmem();
const memoriaGB = (memoriaBytes / (1024 * 1024 * 1024)).toFixed(2);
// Linha 6: Descobrir quantos processadores (CPUs) existem
// os.cpus() retorna um array, então usamos .length para contar
const numeroCPUs = os.cpus().length;
// Linha 7: Calcular há quanto tempo o computador está ligado
// os.uptime() retorna em segundos, vamos converter para horas e minutos
const tempoLigadoSegundos = os.uptime();
const horas = Math.floor(tempoLigadoSegundos / 3600);
const minutos = Math.floor((tempoLigadoSegundos % 3600) / 60);
// Linha 8: Descobrir o nome do usuário logado
// os.userInfo().username nos dá o nome do usuário atual
const nomeUsuario = os.userInfo().username;
// ===== EXIBINDO OS RESULTADOS =====
// Linha 9: Mostrar um cabeçalho bonito
console.log('🖥️ === INFORMAÇÕES DO SISTEMA ===\n');
// Linha 10-14: Mostrar cada informação coletada
console.log('💻 Sistema Operacional:', nomeSistema);
console.log('🧠 Memória RAM Total:', memoriaGB, 'GB');
console.log('⚡ Processadores (CPUs):', numeroCPUs);
console.log('⏰ Tempo Ligado:', horas, 'horas,', minutos, 'minutos');
console.log('👤 Usuário:', nomeUsuario);
// Linha 15: Mensagem final
console.log('\n✅ Análise concluída com sucesso!');
require(): Função que "importa" módulos. É como pedir emprestado ferramentas de outras caixas.
const: Declara uma variável que não vai mudar de valor (constante).
Math.floor(): Arredonda um número para baixo (ex: 3.7 vira 3).
.toFixed(2): Limita um número a 2 casas decimais (ex: 15.999 vira 15.99).
\n: Quebra de linha (como pressionar Enter).
Certifique-se de salvar o arquivo como sistema.js na pasta que você criou.
exercicio-sistema/sistema.js
cd caminho\para\exercicio-sistemacd caminho/para/exercicio-sistemanode sistema.js
Se tudo deu certo, você verá as informações do seu sistema no terminal!
Causa: Erro de digitação no require.
Solução: Verifique se você escreveu require('os') exatamente assim, com aspas simples.
Causa: Node.js não está instalado ou não está no PATH.
Solução: Volte à seção de instalação do Node.js e reinstale.
Causa: Erro de digitação no código.
Solução: Compare seu código com o exemplo. Verifique ponto e vírgula, aspas e parênteses.
Causa: Faltam os comandos console.log().
Solução: Verifique se você incluiu todas as linhas com console.log().
Tente adicionar estas informações ao seu script:
os.arch()os.hostname()os.homedir()Tente fazer o output ficar mais bonito:
Pesquise como usar o módulo fs para salvar as informações em um arquivo .txt
Abra seu editor de código e crie um novo arquivo chamado sistema.js
💻 Como fazer:
VS Code: Ctrl+N → Ctrl+S → digite "sistema.js"
Notepad: Arquivo → Novo → Arquivo → Salvar Como → "sistema.js"
Digite este código no início do arquivo:
// Importar o módulo 'os' (Operating System)
// Este módulo nos dá acesso a informações do sistema operacional
const os = require('os');
🤔 Por que precisamos disso?
O módulo os é como uma "janela" que nos permite "espiar" as informações do computador.
Sem ele, nosso código JavaScript não conseguiria saber nada sobre o sistema.
Agora adicione o código que coleta e exibe as informações:
// Exibir um título bonito
console.log('=== 🖥️ INFORMAÇÕES DO SISTEMA ===');
console.log(''); // Linha em branco para organizar
// Mostrar a plataforma (Windows = win32, Mac = darwin, Linux = linux)
console.log('🖥️ Plataforma:', process.platform);
// Mostrar se é 32 ou 64 bits
console.log('⚙️ Arquitetura:', process.arch);
// Mostrar qual versão do Node.js está instalada
console.log('🟢 Versão do Node.js:', process.version);
// Mostrar em qual pasta estamos executando o script
console.log('📁 Diretório atual:', process.cwd());
// Mostrar qual usuário está logado
console.log('👤 Usuário:', os.userInfo().username);
// Calcular e mostrar a memória RAM total em GB
// os.totalmem() retorna bytes, então dividimos por 1024 três vezes para chegar em GB
const memoriaGB = Math.round(os.totalmem() / 1024 / 1024 / 1024);
console.log('💾 Memória total:', memoriaGB + ' GB');
console.log(''); // Linha em branco
console.log('✅ Análise do sistema concluída!');
Salve o arquivo e execute no terminal:
# Navegar até a pasta onde salvou o arquivo
cd caminho/para/sua/pasta
# Executar o script
node sistema.js
const os = require('os');
Importa o módulo nativo 'os' que contém funções para acessar informações do sistema operacional.
process.platform
Retorna uma string identificando o sistema: 'win32' (Windows), 'darwin' (macOS), 'linux' (Linux).
process.arch
Mostra a arquitetura do processador: 'x64' (64 bits), 'x32' (32 bits), 'arm' (processadores ARM).
process.cwd()
Retorna o caminho completo da pasta onde o script está sendo executado (Current Working Directory).
os.userInfo().username
Acessa as informações do usuário atual e pega apenas o nome de usuário.
Math.round(os.totalmem() / 1024 / 1024 / 1024)
Pega a memória total em bytes, converte para GB (dividindo por 1024³) e arredonda para um número inteiro.
Causa: Este erro não deveria acontecer, pois 'os' é um módulo nativo.
Solução: Verifique se você digitou corretamente: require('os') (com aspas simples).
Causa: Node.js não está instalado ou não está no PATH do sistema.
Solução: Volte à seção de instalação e reinstale o Node.js.
Causa: O terminal não está na pasta correta ou o arquivo não foi salvo.
Solução: Use ls (Mac/Linux) ou dir (Windows) para ver os arquivos na pasta atual.
// sistema.js - Script para exibir informações do sistema
// Criado para aprender sobre módulos nativos do Node.js
// Importar o módulo 'os' (Operating System)
// Este módulo nos dá acesso a informações do sistema operacional
const os = require('os');
// Exibir um título bonito
console.log('=== 🖥️ INFORMAÇÕES DO SISTEMA ===');
console.log(''); // Linha em branco para organizar
// Mostrar a plataforma (Windows = win32, Mac = darwin, Linux = linux)
console.log('🖥️ Plataforma:', process.platform);
// Mostrar se é 32 ou 64 bits
console.log('⚙️ Arquitetura:', process.arch);
// Mostrar qual versão do Node.js está instalada
console.log('🟢 Versão do Node.js:', process.version);
// Mostrar em qual pasta estamos executando o script
console.log('📁 Diretório atual:', process.cwd());
// Mostrar qual usuário está logado
console.log('👤 Usuário:', os.userInfo().username);
// Calcular e mostrar a memória RAM total em GB
// os.totalmem() retorna bytes, então dividimos por 1024 três vezes para chegar em GB
const memoriaGB = Math.round(os.totalmem() / 1024 / 1024 / 1024);
console.log('💾 Memória total:', memoriaGB + ' GB');
console.log(''); // Linha em branco
console.log('✅ Análise do sistema concluída!');
=== 🖥️ INFORMAÇÕES DO SISTEMA === 🖥️ Plataforma: win32 ⚙️ Arquitetura: x64 🟢 Versão do Node.js: v22.17.0 📁 Diretório atual: C:\Users\SeuNome\Desktop\projeto 👤 Usuário: SeuNome 💾 Memória total: 16 GB ✅ Análise do sistema concluída!
Nível: Iniciante | Tempo estimado: 15 minutos
Você vai criar uma calculadora que funciona direto no terminal! Imagine que você está criando uma ferramenta para um caixa de loja que precisa fazer cálculos rápidos. O usuário vai digitar os números e a operação diretamente no comando, assim:
node calculadora.js 10 + 5 Resultado: 10 + 5 = 15 node calculadora.js 20 * 3 Resultado: 20 * 3 = 60
Crie um novo arquivo chamado calculadora.js
Primeiro, vamos "pegar" os argumentos que o usuário digitou:
// calculadora.js - Uma calculadora que funciona no terminal
// process.argv é um array que contém todos os argumentos passados para o script
// [0] = caminho do node, [1] = caminho do script, [2] em diante = nossos argumentos
// slice(2) remove os dois primeiros e fica só com o que nos interessa
const args = process.argv.slice(2);
// Vamos ver o que o usuário digitou (para debug)
console.log('Argumentos recebidos:', args);
🤔 O que é process.argv?
É como uma "caixa de correio" onde o Node.js guarda tudo que foi digitado no terminal.
Se você digitar node calc.js 10 + 5, o array fica assim:
['node', 'calc.js', '10', '+', '5']
Vamos verificar se o usuário digitou tudo certinho:
// Verificar se o usuário passou exatamente 3 argumentos (número, operação, número)
if (args.length !== 3) {
console.log('❌ Ops! Você precisa digitar exatamente 3 coisas:');
console.log('📖 Uso correto: node calculadora.js <número1> <operação> <número2>');
console.log('💡 Exemplo: node calculadora.js 10 + 5');
console.log('⚙️ Operações disponíveis: + - * /');
// process.exit(1) encerra o programa com código de erro
process.exit(1);
}
Agora vamos "extrair" e converter os dados:
// Extrair os valores do array
// args[0] = primeiro número, args[1] = operação, args[2] = segundo número
const num1 = parseFloat(args[0]); // parseFloat converte texto em número decimal
const operacao = args[1]; // a operação fica como texto mesmo
const num2 = parseFloat(args[2]); // segundo número também vira decimal
// Verificar se os números são válidos
if (isNaN(num1) || isNaN(num2)) {
console.log('❌ Erro: Os valores devem ser números válidos!');
console.log('💡 Exemplo correto: node calculadora.js 10.5 + 3.2');
process.exit(1);
}
console.log(`🔢 Calculando: ${num1} ${operacao} ${num2}`);
Agora a parte principal - fazer a conta:
// Variável para guardar o resultado
let resultado;
// switch é como um "menu de opções" - dependendo da operação, faz uma coisa diferente
switch (operacao) {
case '+':
resultado = num1 + num2;
console.log('➕ Fazendo uma soma...');
break;
case '-':
resultado = num1 - num2;
console.log('➖ Fazendo uma subtração...');
break;
case '*':
resultado = num1 * num2;
console.log('✖️ Fazendo uma multiplicação...');
break;
case '/':
// Cuidado especial: não pode dividir por zero!
if (num2 === 0) {
console.log('❌ Erro: Não é possível dividir por zero!');
console.log('🤓 Dica: Divisão por zero é indefinida na matemática.');
process.exit(1);
}
resultado = num1 / num2;
console.log('➗ Fazendo uma divisão...');
break;
default:
// Se a operação não for nenhuma das acima
console.log(`❌ Erro: Operação '${operacao}' não é válida!`);
console.log('⚙️ Operações disponíveis: + - * /');
process.exit(1);
}
Por fim, vamos exibir o resultado de forma bonita:
// Exibir o resultado final
console.log(''); // Linha em branco para organizar
console.log('🎉 Resultado:');
console.log(`${num1} ${operacao} ${num2} = ${resultado}`);
// Se for divisão, mostrar também com mais casas decimais
if (operacao === '/' && resultado % 1 !== 0) {
console.log(`📊 Resultado detalhado: ${resultado.toFixed(4)}`);
}
É um array que contém todos os argumentos passados na linha de comando. Os dois primeiros são sempre o caminho do Node.js e do script.
Converte uma string (texto) em um número decimal. Exemplo: parseFloat('10.5') vira o número 10.5
Verifica se algo "Not a Number" (não é um número). Útil para validar se a conversão deu certo.
Uma forma elegante de fazer múltiplas comparações. É como um "menu" onde cada case é uma opção.
Aqui está o código completo da calculadora. Copie e cole no seu arquivo calculadora.js:
// calculadora.js - Uma calculadora que funciona no terminal
// Criado para aprender Node.js - Conceitos: argumentos, validação, operações
console.log('🧮 === CALCULADORA SIMPLES ===');
console.log('');
// Capturar argumentos da linha de comando
// process.argv contém: [node, script.js, arg1, arg2, arg3...]
// slice(2) remove os dois primeiros e fica só com nossos argumentos
const args = process.argv.slice(2);
// Debug: mostrar o que foi recebido
console.log('📥 Argumentos recebidos:', args);
console.log('');
// Validação: verificar se temos exatamente 3 argumentos
if (args.length !== 3) {
console.log('❌ Ops! Você precisa digitar exatamente 3 coisas:');
console.log('📖 Uso correto: node calculadora.js <número1> <operação> <número2>');
console.log('');
console.log('💡 Exemplos válidos:');
console.log(' node calculadora.js 10 + 5');
console.log(' node calculadora.js 20.5 - 3.2');
console.log(' node calculadora.js 7 * 8');
console.log(' node calculadora.js 15 / 3');
console.log('');
console.log('⚙️ Operações disponíveis: + - * /');
// Encerrar o programa com código de erro
process.exit(1);
}
// Extrair e converter os valores
const num1 = parseFloat(args[0]); // Primeiro número
const operacao = args[1]; // Operação (+, -, *, /)
const num2 = parseFloat(args[2]); // Segundo número
// Validar se os números são válidos
if (isNaN(num1) || isNaN(num2)) {
console.log('❌ Erro: Os valores devem ser números válidos!');
console.log('');
console.log('💡 Exemplos de números válidos:');
console.log(' ✅ 10, 5.5, -3, 0, 100.25');
console.log(' ❌ abc, 10a, texto, vazio');
console.log('');
console.log('🔄 Tente novamente com números válidos.');
process.exit(1);
}
// Mostrar o que vamos calcular
console.log(`🔢 Calculando: ${num1} ${operacao} ${num2}`);
console.log('');
// Variável para armazenar o resultado
let resultado;
// Realizar a operação usando switch
switch (operacao) {
case '+':
resultado = num1 + num2;
console.log('➕ Realizando soma...');
break;
case '-':
resultado = num1 - num2;
console.log('➖ Realizando subtração...');
break;
case '*':
resultado = num1 * num2;
console.log('✖️ Realizando multiplicação...');
break;
case '/':
// Verificação especial: divisão por zero
if (num2 === 0) {
console.log('❌ Erro: Não é possível dividir por zero!');
console.log('');
console.log('🤓 Explicação: Na matemática, divisão por zero é indefinida.');
console.log('💡 Tente usar um número diferente de zero como divisor.');
process.exit(1);
}
resultado = num1 / num2;
console.log('➗ Realizando divisão...');
break;
default:
// Operação não reconhecida
console.log(`❌ Erro: Operação '${operacao}' não é válida!`);
console.log('');
console.log('⚙️ Operações disponíveis:');
console.log(' + (soma)');
console.log(' - (subtração)');
console.log(' * (multiplicação)');
console.log(' / (divisão)');
console.log('');
console.log('🔄 Tente novamente com uma operação válida.');
process.exit(1);
}
// Exibir o resultado
console.log('');
console.log('🎉 === RESULTADO ===');
console.log(`${num1} ${operacao} ${num2} = ${resultado}`);
// Para divisões, mostrar resultado com mais precisão se necessário
if (operacao === '/' && resultado % 1 !== 0) {
console.log(`📊 Resultado detalhado: ${resultado.toFixed(6)}`);
}
// Informações extras baseadas no resultado
if (resultado < 0) {
console.log('📝 Nota: O resultado é negativo.');
} else if (resultado === 0) {
console.log('📝 Nota: O resultado é zero.');
} else if (resultado > 1000) {
console.log('📝 Nota: Resultado grande! 🚀');
}
console.log('');
console.log('✅ Cálculo concluído com sucesso!');
cd caminho/para/sua/pasta
node calculadora.js 10 + 5
node calculadora.js 15 + 25 → Resultado: 15 + 25 = 40
node calculadora.js 100 - 30 → Resultado: 100 - 30 = 70
node calculadora.js 7 * 8 → Resultado: 7 * 8 = 56
node calculadora.js 20 / 4 → Resultado: 20 / 4 = 5
node calculadora.js 10.5 + 3.2 → Resultado: 10.5 + 3.2 = 13.7
Causa: Node.js não está instalado ou não está no PATH
Solução: Instale o Node.js do site oficial (nodejs.org) e reinicie o terminal
Causa: Arquivo não encontrado ou você está na pasta errada
Solução: Use dir (Windows) ou ls (Mac/Linux) para ver os arquivos na pasta atual
Causa: Você passou texto em vez de números
Solução: Use apenas números. Exemplo: node calculadora.js 10 + 5
Causa: Você usou um símbolo que não é +, -, *, /
Solução: Use apenas: + (soma), - (subtração), * (multiplicação), / (divisão)
Causa: Você tentou dividir um número por 0
Solução: Use qualquer número diferente de zero como divisor
Adicione uma operação de potência (^) que eleva o primeiro número à potência do segundo
Faça a calculadora funcionar com mais de 2 números: node calc.js 1 + 2 + 3 + 4
Adicione parênteses para controlar a ordem das operações: node calc.js "(2 + 3) * 4"
Salve o histórico de cálculos em um arquivo historico.txt
Causa: Você não digitou os 3 argumentos necessários.
Solução: Digite exatamente: node calculadora.js 10 + 5
Causa: Você digitou algo que não é número (como letras).
Solução: Use apenas números: node calculadora.js 15.5 * 2
Causa: No Windows, alguns símbolos precisam de aspas.
Solução: Use aspas: node calculadora.js 10 "*" 5
// calculadora.js - Uma calculadora que funciona no terminal
// Criado para aprender sobre argumentos de linha de comando
// process.argv é um array que contém todos os argumentos passados para o script
// [0] = caminho do node, [1] = caminho do script, [2] em diante = nossos argumentos
// slice(2) remove os dois primeiros e fica só com o que nos interessa
const args = process.argv.slice(2);
// Verificar se o usuário passou exatamente 3 argumentos (número, operação, número)
if (args.length !== 3) {
console.log('❌ Ops! Você precisa digitar exatamente 3 coisas:');
console.log('📖 Uso correto: node calculadora.js <número1> <operação> <número2>');
console.log('💡 Exemplo: node calculadora.js 10 + 5');
console.log('⚙️ Operações disponíveis: + - * /');
// process.exit(1) encerra o programa com código de erro
process.exit(1);
}
// Extrair os valores do array
// args[0] = primeiro número, args[1] = operação, args[2] = segundo número
const num1 = parseFloat(args[0]); // parseFloat converte texto em número decimal
const operacao = args[1]; // a operação fica como texto mesmo
const num2 = parseFloat(args[2]); // segundo número também vira decimal
// Verificar se os números são válidos
if (isNaN(num1) || isNaN(num2)) {
console.log('❌ Erro: Os valores devem ser números válidos!');
console.log('💡 Exemplo correto: node calculadora.js 10.5 + 3.2');
process.exit(1);
}
console.log(`🔢 Calculando: ${num1} ${operacao} ${num2}`);
// Variável para guardar o resultado
let resultado;
// switch é como um "menu de opções" - dependendo da operação, faz uma coisa diferente
switch (operacao) {
case '+':
resultado = num1 + num2;
console.log('➕ Fazendo uma soma...');
break;
case '-':
resultado = num1 - num2;
console.log('➖ Fazendo uma subtração...');
break;
case '*':
resultado = num1 * num2;
console.log('✖️ Fazendo uma multiplicação...');
break;
case '/':
// Cuidado especial: não pode dividir por zero!
if (num2 === 0) {
console.log('❌ Erro: Não é possível dividir por zero!');
console.log('🤓 Dica: Divisão por zero é indefinida na matemática.');
process.exit(1);
}
resultado = num1 / num2;
console.log('➗ Fazendo uma divisão...');
break;
default:
// Se a operação não for nenhuma das acima
console.log(`❌ Erro: Operação '${operacao}' não é válida!`);
console.log('⚙️ Operações disponíveis: + - * /');
process.exit(1);
}
// Exibir o resultado final
console.log(''); // Linha em branco para organizar
console.log('🎉 Resultado:');
console.log(`${num1} ${operacao} ${num2} = ${resultado}`);
// Se for divisão, mostrar também com mais casas decimais
if (operacao === '/' && resultado % 1 !== 0) {
console.log(`📊 Resultado detalhado: ${resultado.toFixed(4)}`);
}
$ node calculadora.js 10 + 5 🔢 Calculando: 10 + 5 ➕ Fazendo uma soma... 🎉 Resultado: 10 + 5 = 15 $ node calculadora.js 20 / 3 🔢 Calculando: 20 / 3 ➗ Fazendo uma divisão... 🎉 Resultado: 20 / 3 = 6.666666666666667 📊 Resultado detalhado: 6.6667
Nível: Iniciante | Tempo estimado: 10 minutos
Imagine que você foi contratado para criar um sistema para uma padaria chamada "Doce Sabor". Você precisa criar um package.json que organize todos os scripts e informações do projeto. É como criar um "manual de instruções" para o seu projeto!
Sua padaria precisa de um sistema que tenha:
Crie um arquivo chamado package.json na pasta do seu projeto
⚠️ Atenção!
O arquivo DEVE se chamar exatamente package.json (tudo minúsculo, sem espaços).
Este é um nome especial que o Node.js reconhece automaticamente.
Comece com a estrutura básica do JSON:
{
}
🤔 O que é JSON?
JSON é como um "formulário" estruturado. Cada informação tem um nome (chave) e um valor. É muito parecido com JavaScript, mas mais rigoroso com aspas e vírgulas.
Adicione as informações principais:
{
"name": "padaria-doce-sabor",
"version": "1.0.0",
"description": "Sistema de gerenciamento para padaria",
"main": "index.js",
"author": "Seu Nome Aqui",
"license": "MIT"
}
💡 Explicação de cada campo:
Agora a parte mais legal - criar comandos personalizados:
{
"name": "padaria-doce-sabor",
"version": "1.0.0",
"description": "Sistema de gerenciamento para padaria",
"main": "index.js",
"scripts": {
"start": "node index.js",
"dev": "node --watch index.js",
"info": "node sistema.js",
"calc": "node calculadora.js"
},
"author": "Seu Nome Aqui",
"license": "MIT"
}
🎯 Como usar os scripts:
npm start → Inicia o sistema principalnpm run dev → Modo desenvolvimento (reinicia automaticamente)npm run info → Mostra informações do sistemanpm run calc → Abre a calculadoraPara finalizar, adicione palavras-chave que descrevem seu projeto:
{
"name": "padaria-doce-sabor",
"version": "1.0.0",
"description": "Sistema de gerenciamento para padaria",
"main": "index.js",
"scripts": {
"start": "node index.js",
"dev": "node --watch index.js",
"info": "node sistema.js",
"calc": "node calculadora.js"
},
"keywords": [
"padaria",
"nodejs",
"backend",
"sistema",
"gerenciamento"
],
"author": "Seu Nome Aqui",
"license": "MIT"
}
Depois de criar o package.json, você pode testar os comandos:
npm run info
Deve executar o script sistema.js que você criou no exercício 1
npm run calc 10 + 5
Deve executar a calculadora com os argumentos 10 + 5
Causa: Erro de sintaxe no JSON (vírgula extra, aspas faltando, etc.)
Solução: Verifique se todas as chaves têm aspas duplas e se não há vírgula após o último item.
Causa: NPM não está instalado ou não está no PATH.
Solução: Reinstale o Node.js (que inclui o NPM automaticamente).
Causa: O arquivo referenciado no script não existe.
Solução: Certifique-se de que os arquivos sistema.js e calculadora.js existem na mesma pasta.
{
"name": "padaria-doce-sabor",
"version": "1.0.0",
"description": "Sistema de gerenciamento para padaria - Projeto de aprendizado Node.js",
"main": "index.js",
"scripts": {
"start": "node index.js",
"dev": "node --watch index.js",
"info": "node sistema.js",
"calc": "node calculadora.js",
"test": "echo \"Testes ainda não implementados\" && exit 1"
},
"keywords": [
"padaria",
"nodejs",
"backend",
"sistema",
"gerenciamento",
"aprendizado"
],
"author": "Seu Nome Aqui",
"license": "MIT",
"engines": {
"node": ">=18.0.0"
}
}
npm start - Inicia o sistema principal
npm run dev - Modo desenvolvimento
npm run info - Informações do sistema
npm run calc 10 + 5 - Calculadora
Você deu seus primeiros passos no mundo do desenvolvimento backend com Node.js! Esta foi uma jornada importante e você deve se orgulhar do que aprendeu.
Script que mostra dados do computador usando módulos nativos do Node.js
node sistema.js
Aplicação que processa argumentos da linha de comando para fazer cálculos
node calc.js 10 + 5
Package.json com scripts personalizados para gerenciar o projeto
npm run info
Node.js não é uma linguagem: É um ambiente de execução para JavaScript.
Event Loop: Permite que o Node.js seja assíncrono e eficiente.
NPM: Gerenciador de pacotes que facilita o uso de bibliotecas.
package.json: "Carteira de identidade" do seu projeto Node.js.
Na próxima aula, você vai dar um grande salto! Vamos criar seu primeiro servidor web que pode ser acessado pelo navegador. Imagine poder digitar um endereço e ver sua própria página!
💡 Dica: Antes da próxima aula, pratique os exercícios desta aula. Quanto mais confortável você estiver com o terminal e scripts básicos, mais fácil será entender servidores web!
🌟 Você está no caminho certo! Cada linha de código que você escreve te aproxima de se tornar um desenvolvedor backend. Continue assim!
Esta é a primeira aula