Iniciante 2 horas

Aula 1: Introdução ao Node.js

Fundamentos básicos do Node.js e configuração do ambiente de desenvolvimento

🎯 Objetivos da Aula

  • Compreender o que é Node.js e seu ecossistema
  • Configurar ambiente de desenvolvimento
  • Executar primeiro script Node.js

🚀 Antes de Começar

Bem-vindo ao mundo do desenvolvimento backend!

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! 🚴‍♂️

🛠️ Preparação do Ambiente de Desenvolvimento

IMPORTANTE: Configuração Obrigatória

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!

1. Editor de Código

O que é: Um programa especial para escrever código de forma organizada, com cores e recursos que facilitam a programação.

Recomendado: Visual Studio Code
  • ✅ Gratuito e muito popular
  • ✅ Fácil de usar para iniciantes
  • ✅ Muitas extensões úteis
  • ✅ Funciona no Windows, Mac e Linux
Baixar VS Code
Outras opções:

Sublime Text, Atom, Notepad++ (mas recomendamos o VS Code)

2. Terminal/Prompt

O que é: Uma interface de texto onde você digita comandos para o computador executar. É como "conversar" com o computador usando texto.

Windows:

PowerShell ou Prompt de Comando (já vem instalado)

Como abrir: Pressione Win + R, digite "powershell" e aperte Enter

macOS:

Terminal (já vem instalado)

Como abrir: Cmd + Espaço, digite "terminal" e aperte Enter

Linux:

Terminal (já vem instalado)

Como abrir: Ctrl + Alt + T ou procure por "Terminal" no menu

📚 Conhecimentos Básicos (Não se preocupe se não souber!)

Relaxe! Vamos explicar tudo

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!

Variáveis

"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

Funções

"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é

Loops

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

✅ Lista de Verificação Antes de Começar

Marque cada item conforme você for completando:

🎯 O que você vai aprender hoje:

Conceitos Fundamentais

  • O que é Node.js e por que é revolucionário
  • Diferença entre frontend e backend (com analogias)
  • Como funciona o Event Loop (de forma simples)
  • O que são servidores e como funcionam

Habilidades Práticas

  • Instalar Node.js corretamente no seu sistema
  • Criar e executar scripts JavaScript
  • Usar o NPM para gerenciar bibliotecas
  • Resolver problemas comuns (troubleshooting)

🚀 Ao final desta aula você será capaz de:

  • Criar seus próprios programas Node.js
  • Instalar e usar bibliotecas externas
  • Entender como funciona o desenvolvimento backend
  • Ter confiança para continuar aprendendo

💪 Vamos começar esta jornada incrível juntos!

1. Introdução ao Mundo Backend

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.

🤔 Mas afinal, o que é Backend?

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!

Frontend (Cliente)

  • • Interface que o usuário vê
  • • Roda no navegador
  • • HTML, CSS, JavaScript
  • • React, Vue, Angular

Backend (Servidor)

  • • Lógica de negócio
  • • Roda no servidor
  • • Banco de dados
  • • APIs e autenticação

🎯 Por que Node.js?

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!

2. O que é Node.js?

📖 Definição Simples:

Node.js é um ambiente de execução que permite rodar código JavaScript fora do navegador, diretamente no seu computador ou servidor.

🤯 Mas como isso é possível?

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!

JavaScript no Navegador

  • • Manipula elementos HTML
  • • Responde a cliques e eventos
  • • Faz requisições para APIs
  • • Limitado ao ambiente do browser

JavaScript no Node.js

  • • Acessa arquivos do sistema
  • • Conecta com bancos de dados
  • • Cria servidores web
  • • Executa no servidor/computador

🚀 Características Principais do Node.js:

Assíncrono e Orientado a Eventos

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.

Single-threaded com Event Loop

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.

NPM - Maior Ecossistema do Mundo

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!

Cross-platform

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!

💡 Resumo em Uma Frase:

Node.js = JavaScript + Superpoderes para rodar no servidor!

3. História e Evolução

2009

Criação do Node.js

Ryan Dahl cria o Node.js para resolver problemas de I/O não-bloqueante

2010

NPM é lançado

Isaac Schlueter cria o Node Package Manager

2015

Node.js Foundation

Criação da fundação para governança do projeto

Hoje

Ecossistema Maduro

Milhões de pacotes no NPM e adoção massiva na indústria

4. Event Loop e Arquitetura Assíncrona

🤔 O que é o Event Loop?

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.

🏪 Analogia: Loja com Um Funcionário

Imagine uma loja com apenas um funcionário (single-threaded), mas que é super eficiente:

  • Cliente 1: "Quero um produto que está no estoque" → Funcionário pega rapidamente
  • Cliente 2: "Quero um produto que precisa ser encomendado" → Funcionário faz o pedido e vai atender outros
  • Cliente 3: "Quero pagar" → Funcionário processa o pagamento
  • • Quando a encomenda do Cliente 2 chega, o funcionário volta para ele

O funcionário nunca fica parado esperando! Isso é o Event Loop em ação.

🔧 Como Funciona na Prática:

Call Stack (Pilha de Execução)

O que é: A "mesa de trabalho" onde o código é executado

Como funciona: Executa uma função por vez, de cima para baixo

Callback Queue (Fila de Callbacks)

O que é: A "fila de espera" para funções que terminaram operações assíncronas

Como funciona: Aguarda sua vez para ser executada

Event Loop (Laço de Eventos)

O que é: O "gerente" que coordena tudo

Como funciona: Verifica se a Call Stack está vazia e move callbacks da fila

Thread Pool (Pool de Threads)

O que é: "Funcionários extras" para tarefas pesadas

Como funciona: Executa operações como leitura de arquivos em paralelo

🔄 O Ciclo Completo:

  1. 1. Código JavaScript entra na Call Stack
  2. 2. Se for operação assíncrona (ex: ler arquivo), vai para Thread Pool
  3. 3. Call Stack continua executando outras coisas
  4. 4. Quando operação assíncrona termina, callback vai para Callback Queue
  5. 5. Event Loop verifica: Call Stack vazia? Move callback da fila para stack
  6. 6. Callback é executado

💻 Exemplo Prático Comentado:

Código:

// 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');

📤 Saída no Terminal:

🚀 Início do programa
📝 Meio do programa  
🏁 Fim do programa
⏰ Timeout executado após 0ms
⏰ Segundo timeout executado

🤯 Por que essa ordem?

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

🎯 Por que isso é Importante?

Performance

Seu servidor pode atender milhares de usuários simultaneamente sem "travar" esperando operações lentas.

Escalabilidade

Enquanto um usuário espera dados do banco, o servidor pode processar requisições de outros usuários.

💡 Resumo em Uma Frase:

Event Loop = Node.js fazendo malabarismo com tarefas para nunca ficar parado! 🤹‍♂️

5. Como Instalar o Node.js no Seu Computador

📋 Antes de Começar

✅ O que você vai precisar:

  • Conexão com internet
  • Permissão de administrador no seu computador
  • Cerca de 10-15 minutos

💡 Dica: Sempre escolha a versão LTS (Long Term Support) - é a mais estável!

🪟

Windows

Passo a Passo:

  1. 1. Abra seu navegador
  2. 2. Vá para nodejs.org
  3. 3. Clique no botão verde "LTS" (versão recomendada)
  4. 4. Aguarde o download do arquivo .msi
  5. 5. Clique duas vezes no arquivo baixado
  6. 6. Clique "Next" em todas as telas
  7. 7. Clique "Install" e aguarde
  8. 8. Clique "Finish" quando terminar

⚠️ Importante: Se aparecer uma janela pedindo permissão de administrador, clique "Sim".

🍎

macOS

Método 1 - Site Oficial:

  1. 1. Vá para nodejs.org
  2. 2. Baixe a versão LTS
  3. 3. Abra o arquivo .pkg
  4. 4. Siga o instalador

Método 2 - Homebrew:

Se você tem Homebrew instalado:

brew install node
🐧

Linux

Ubuntu/Debian:

sudo apt update
sudo apt install nodejs npm

CentOS/RHEL:

sudo yum install nodejs npm

🔍 Testando se Deu Certo

📍 Onde abrir o terminal:

Windows:
Pressione Win + R, digite cmd e pressione Enter
macOS:
Pressione Cmd + Space, digite "Terminal" e pressione Enter
Linux:
Pressione Ctrl + Alt + T

Digite estes comandos no terminal:

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

✅ Se deu certo:

Você verá números de versão aparecendo no terminal. Parabéns! O Node.js está instalado e funcionando!

❌ Se não deu certo:

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"

6. Seu Primeiro Script Node.js

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.

🎯 O que é um Script?

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).

📝 Passo 1: Onde Criar o Arquivo

🪟 No Windows:

  1. Abra o Explorador de Arquivos (tecla Windows + E)
  2. Navegue até uma pasta de sua escolha (ex: Documentos)
  3. Crie uma nova pasta chamada "meus-scripts-nodejs"
  4. Entre nesta pasta
  5. Clique com o botão direito → "Novo" → "Documento de Texto"
  6. Renomeie de "Novo Documento de Texto.txt" para "hello.js"
  7. Confirme a mudança de extensão quando perguntado

🍎 No macOS:

  1. Abra o Finder
  2. Vá para a pasta "Documentos"
  3. Crie uma nova pasta "meus-scripts-nodejs"
  4. Abra um editor de texto (TextEdit, VS Code, etc.)
  5. Salve o arquivo como "hello.js" na pasta criada

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".

✍️ Passo 2: Escrever o Código

Agora vamos escrever nosso primeiro código. Abra o arquivo hello.js em qualquer editor de texto e digite exatamente isto:

📝 Editores Recomendados:

VS Code
Gratuito, muito usado por programadores
Notepad++
Windows, simples e eficiente
Bloco de Notas
Funciona, mas é bem básico
// 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);

🔍 Explicação Linha por Linha:

// 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!

🚀 Passo 3: Executar o Script

Agora vem a parte emocionante: Vamos executar nosso código e ver ele funcionando!

📍 Passo 3.1: Abrir o Terminal

🪟 Windows

Opção 1: Win + R → digite "cmd" → Enter

Opção 2: Win + X → "Prompt de Comando"

Opção 3: Pesquisar "cmd" no menu Iniciar

🍎 macOS

Opção 1: Cmd + Space → "Terminal" → Enter

Opção 2: Aplicações → Utilitários → Terminal

Opção 3: Launchpad → Terminal

🐧 Linux

Opção 1: Ctrl + Alt + T

Opção 2: Menu → Terminal

Opção 3: Pesquisar "terminal"

📂 Passo 3.2: Navegar até a Pasta do Arquivo

O terminal sempre "está" em alguma pasta. Precisamos ir até a pasta onde salvamos nosso arquivo hello.js.

🗺️ Comandos de Navegação:
cd nome-da-pasta Entra em uma pasta
cd .. Volta uma pasta
dir (Windows) ou ls (Mac/Linux) Lista arquivos da pasta atual
💡 Exemplo Prático:

Se você salvou o arquivo em "Documentos/meus-scripts-nodejs", digite:

Windows:
cd Documents\meus-scripts-nodejs
macOS/Linux:
cd Documents/meus-scripts-nodejs

⚡ Passo 3.3: Executar o Script

Agora que estamos na pasta certa, vamos executar nosso script com o comando mágico:

node hello.js
🔍 O que significa este comando:
node Chama o programa Node.js
hello.js Nome do arquivo que queremos executar
✅ Se deu certo, você verá:
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!

// console.log() é uma função que exibe texto na tela console.log('Hello, World!'); // Exibe "Hello, World!" console.log('Bem-vindo ao Node.js!'); // Exibe uma mensagem de boas-vindas // O objeto 'process' contém informações sobre o programa em execução console.log('Versão do Node.js:', process.version); // Mostra qual versão do Node.js está rodando console.log('Plataforma:', process.platform); // Mostra o sistema operacional (win32, darwin, linux)

🔍 Explicação Linha por Linha:

// 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.

🚀 Passo 3: Executar o Script

Abrir o Terminal/Prompt:

🪟 Windows:
  • Opção 1: Pressione Windows + R, digite "cmd" e pressione Enter
  • Opção 2: Pressione Windows + X e escolha "Terminal" ou "PowerShell"
  • Opção 3: No Explorador de Arquivos, segure Shift + clique direito na pasta → "Abrir janela do PowerShell aqui"
🍎 macOS:
  • Opção 1: Pressione Cmd + Espaço, digite "Terminal" e pressione Enter
  • Opção 2: Vá em Aplicações → Utilitários → Terminal

Navegar até a Pasta do Arquivo:

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!

Executar o Script:

Agora digite o comando mágico que vai executar seu primeiro programa Node.js:

node hello.js

🎉 Resultado Esperado:

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!

🔧 Troubleshooting (Resolução de Problemas)

❌ Erro: "'node' não é reconhecido como comando"

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.

❌ Erro: "Não foi possível encontrar o arquivo hello.js"

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.

❌ Erro: "SyntaxError: Unexpected token"

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.

7. NPM - Node Package Manager

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 que é o NPM?

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!

📦 O que são "Pacotes"?

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.

🌍 Quantos Pacotes Existem?

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 que é o package.json?

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.

🔍 O que tem dentro do package.json:

📝 Informações Básicas:
  • • Nome do projeto
  • • Versão atual
  • • Descrição do que faz
  • • Autor (você!)
📦 Dependências:
  • • Quais pacotes o projeto usa
  • • Versões específicas
  • • Scripts personalizados
  • • Configurações especiais

🚀 Criando seu Primeiro package.json

📍 Passo 1: Criar uma Nova Pasta para o Projeto

Primeiro, vamos criar uma pasta para nosso projeto NPM. Abra o terminal e digite:

🪟 Windows:
mkdir meu-primeiro-projeto-npm
cd meu-primeiro-projeto-npm
🍎 macOS/Linux:
mkdir meu-primeiro-projeto-npm
cd meu-primeiro-projeto-npm
🔍 O que estes comandos fazem:

mkdir = "make directory" = criar pasta

cd = "change directory" = entrar na pasta

📋 Passo 2: Inicializar o NPM

Agora vamos criar o arquivo package.json. Existem duas formas:

🎯 Método 1: Modo Interativo (Recomendado para Iniciantes)
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

⚡ Método 2: Modo Rápido
npm init -y

O -y significa "yes" para tudo. Cria um package.json básico instantaneamente.

📄 Passo 3: Ver o Resultado

Após executar o comando, um arquivo package.json será criado. Vamos ver o que tem dentro:

📋 Para ver o conteúdo:
Windows:
type package.json
macOS/Linux:
cat package.json
✅ Você verá algo assim:
{
  "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"
}

📦 Comandos Essenciais do NPM

🔽 Instalando Pacotes

Instalar um pacote específico:
npm install nome-do-pacote

Exemplo: npm install colors (pacote para colorir texto no terminal)

Instalar todas as dependências:
npm install

Instala todos os pacotes listados no package.json

Instalar globalmente:
npm install -g nome-do-pacote

O -g instala o pacote para uso em qualquer lugar do computador

🔍 Comandos de Informação

Ver pacotes instalados:
npm list
Ver versão do NPM:
npm --version
Buscar pacotes:
npm search nome
Informações de um pacote:
npm info nome-do-pacote

🗑️ Removendo Pacotes

Remover um pacote:
npm uninstall nome-do-pacote

Remove o pacote do projeto e atualiza o package.json

📄 O que é o package.json?

O package.json é como a "certidão de nascimento" do seu projeto. Ele contém informações importantes como:

  • Nome do projeto: Como seu projeto se chama
  • Versão: Qual versão do seu projeto (1.0.0, 2.1.3, etc.)
  • Dependências: Quais pacotes seu projeto precisa para funcionar
  • Scripts: Comandos personalizados que você pode executar
  • Autor: Quem criou o projeto

🚀 Criando seu Primeiro package.json

Método 1: Interativo (Recomendado para Iniciantes)

Este método faz perguntas e você responde. É ótimo para aprender!

# Abra o terminal na pasta do seu projeto e digite:
npm init
📝 Perguntas que o NPM vai fazer:
package name: (nome-da-pasta-atual)
version: (1.0.0)
description: Digite uma descrição ou pressione Enter
entry point: (index.js)
author: Digite seu nome

💡 Valores entre parênteses são sugestões. Pressione Enter para aceitar ou digite algo diferente.

Método 2: Automático (Mais Rápido)

Este método cria o package.json automaticamente com valores padrão:

# Cria package.json com valores padrão (sem perguntas)
npm init -y

🎉 Resultado:

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"
}

🛠️ Comandos Essenciais do NPM

Instalar um Pacote Específico

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.

Instalar Todas as Dependências

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 Scripts

# 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 Pacotes Instalados

# 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.

📁 Estrutura de Pastas Após Usar NPM

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.

🎯 Exemplo Prático: Criando um Projeto Completo

Passo 1: Criar pasta e navegar

# Criar uma nova pasta
mkdir minha-padaria-app

# Entrar na pasta
cd minha-padaria-app

Passo 2: Inicializar projeto NPM

# Criar package.json
npm init -y

Passo 3: Instalar um pacote útil

# Instalar o pacote 'colors' para texto colorido
npm install colors

Passo 4: Criar um arquivo que usa o pacote

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);

Passo 5: Executar o projeto

node app.js

Você verá texto colorido no terminal! 🌈

8. 🎯 Exercícios Práticos

🎯 Objetivo dos Exercícios

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!

📝 Exercício 1: Informações do Sistema

Nível: Iniciante | Tempo estimado: 10 minutos

🎯 O que você vai aprender:

  • Como acessar informações do sistema operacional
  • Usar módulos nativos do Node.js (os e process)
  • Formatar e exibir dados no terminal
  • Trabalhar com cálculos matemáticos simples

📋 Descrição do Exercício

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:

  • Qual sistema operacional está rodando (Windows, Mac, Linux)
  • Quantidade de memória RAM disponível
  • Quantos processadores (CPUs) o computador tem
  • Há quanto tempo o computador está ligado
  • Nome do usuário logado

🎯 Resultado Final Esperado:

🖥️  === 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!

📝 Passo a Passo Detalhado

🗂️ Passo 1: Preparar o Ambiente
1.1 Criar pasta para o exercício:
# 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.

1.2 Criar o arquivo do script:

Abra seu editor de código favorito (VS Code, Notepad++, etc.) e crie um arquivo chamado sistema.js

💡 Dica: No VS Code, você pode usar Ctrl+N para criar um novo arquivo, depois Ctrl+S para salvar com o nome "sistema.js"
💻 Passo 2: Escrever o Código (Explicado Linha por Linha)

Agora vamos escrever o código. Vou explicar cada linha para você entender exatamente o que está acontecendo:

📋 Código Completo com Explicações:
// ===== 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!');
🔍 Conceitos Importantes Explicados:

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).

🚀 Passo 3: Executar e Testar
3.1 Salvar o arquivo:

Certifique-se de salvar o arquivo como sistema.js na pasta que você criou.

✅ Verificação: O arquivo deve estar em: exercicio-sistema/sistema.js
3.2 Abrir o terminal na pasta correta:
🪟 Windows:
  • • Abra o Prompt de Comando ou PowerShell
  • • Digite: cd caminho\para\exercicio-sistema
  • • Ou navegue pelo Explorer, clique na barra de endereço e digite "cmd"
🍎 macOS/Linux:
  • • Abra o Terminal
  • • Digite: cd caminho/para/exercicio-sistema
  • • Ou arraste a pasta para o Terminal
3.3 Executar o script:
node sistema.js

Se tudo deu certo, você verá as informações do seu sistema no terminal!

🔧 Troubleshooting (Se Algo Der Errado)
❌ Erro: "Cannot find module 'os'"

Causa: Erro de digitação no require.

Solução: Verifique se você escreveu require('os') exatamente assim, com aspas simples.

❌ Erro: "node não é reconhecido"

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.

❌ Erro: "SyntaxError: Unexpected token"

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.

❌ O script roda mas não mostra nada

Causa: Faltam os comandos console.log().

Solução: Verifique se você incluiu todas as linhas com console.log().

🎯 Desafios Extras (Para Quem Quer Ir Além)
🌟 Desafio 1: Adicionar Mais Informações

Tente adicionar estas informações ao seu script:

  • Arquitetura do processador (32 ou 64 bits): os.arch()
  • Nome do computador: os.hostname()
  • Diretório home do usuário: os.homedir()
🌟 Desafio 2: Melhorar a Formatação

Tente fazer o output ficar mais bonito:

  • Adicione mais emojis e cores
  • Crie bordas com caracteres como ═══
  • Alinhe as informações em colunas
🌟 Desafio 3: Salvar em Arquivo

Pesquise como usar o módulo fs para salvar as informações em um arquivo .txt

  • Se o processador é 32 ou 64 bits
  • Qual versão do Node.js está instalada
  • Em qual pasta o script está sendo executado
  • Qual usuário está logado no sistema
  • Quanta memória RAM o computador tem
  • 🛠️ Passo a Passo

    Passo 1: Criar o arquivo

    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"

    Passo 2: Importar os módulos necessários

    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.

    Passo 3: Criar o código principal

    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!');
    Passo 4: Salvar e executar

    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
    💡 Explicação Linha por Linha
    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.

    🚨 Troubleshooting - Problemas Comuns
    ❌ Erro: "Cannot find module 'os'"

    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).

    ❌ Erro: "node: command not found"

    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.

    ❌ Erro: "No such file or directory"

    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.

    ✅ Código Completo da Solução
    // 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!');
    🎉 Resultado Esperado:
    ===  🖥️  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!

    📝 Exercício 2: Calculadora Simples

    Nível: Iniciante | Tempo estimado: 15 minutos

    🎯 O que você vai aprender:

    • Como capturar argumentos da linha de comando
    • Trabalhar com arrays e manipulação de dados
    • Usar estruturas condicionais (if/switch)
    • Validar entrada de dados do usuário
    • Converter strings em números

    📋 Descrição do Exercício

    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:

    💡 Exemplo de uso:
    node calculadora.js 10 + 5
    Resultado: 10 + 5 = 15
    
    node calculadora.js 20 * 3
    Resultado: 20 * 3 = 60

    🛠️ Passo a Passo

    Passo 1: Criar o arquivo

    Crie um novo arquivo chamado calculadora.js

    Passo 2: Capturar os argumentos

    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']

    Passo 3: Validar a entrada

    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);
    }
    Passo 4: Processar os dados

    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}`);
    Passo 5: Fazer o cálculo

    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);
    }
    Passo 6: Mostrar o resultado

    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)}`);
    }
    💡 Explicação dos Conceitos
    process.argv

    É 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.

    parseFloat()

    Converte uma string (texto) em um número decimal. Exemplo: parseFloat('10.5') vira o número 10.5

    isNaN()

    Verifica se algo "Not a Number" (não é um número). Útil para validar se a conversão deu certo.

    switch/case

    Uma forma elegante de fazer múltiplas comparações. É como um "menu" onde cada case é uma opção.

    📝 Código Completo

    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!');

    🎯 Como Executar

    1. Abrir o Terminal:
    • Windows: Pressione Win + R, digite "cmd" e Enter
    • macOS: Pressione Cmd + Espaço, digite "terminal" e Enter
    • Linux: Pressione Ctrl + Alt + T
    2. Navegar até a pasta do arquivo:
    cd caminho/para/sua/pasta
    3. Executar a calculadora:
    node calculadora.js 10 + 5

    🧪 Exemplos de Teste

    Soma:
    node calculadora.js 15 + 25
    → Resultado: 15 + 25 = 40
    Subtração:
    node calculadora.js 100 - 30
    → Resultado: 100 - 30 = 70
    Multiplicação:
    node calculadora.js 7 * 8
    → Resultado: 7 * 8 = 56
    Divisão:
    node calculadora.js 20 / 4
    → Resultado: 20 / 4 = 5
    Números decimais:
    node calculadora.js 10.5 + 3.2
    → Resultado: 10.5 + 3.2 = 13.7

    🚨 Troubleshooting (Resolução de Problemas)

    Erro: "node não é reconhecido"

    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

    Erro: "cannot find module"

    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

    Resultado estranho ou NaN

    Causa: Você passou texto em vez de números

    Solução: Use apenas números. Exemplo: node calculadora.js 10 + 5

    "Operação não é válida"

    Causa: Você usou um símbolo que não é +, -, *, /

    Solução: Use apenas: + (soma), - (subtração), * (multiplicação), / (divisão)

    "Não é possível dividir por zero"

    Causa: Você tentou dividir um número por 0

    Solução: Use qualquer número diferente de zero como divisor

    🎯 Desafios Extras

    🔥
    Nível Fácil:

    Adicione uma operação de potência (^) que eleva o primeiro número à potência do segundo

    🔥🔥
    Nível Médio:

    Faça a calculadora funcionar com mais de 2 números: node calc.js 1 + 2 + 3 + 4

    🔥🔥🔥
    Nível Difícil:

    Adicione parênteses para controlar a ordem das operações: node calc.js "(2 + 3) * 4"

    💾
    Bonus:

    Salve o histórico de cálculos em um arquivo historico.txt

    🚨 Troubleshooting - Problemas Comuns
    ❌ "Uso correto: node calculadora.js..."

    Causa: Você não digitou os 3 argumentos necessários.

    Solução: Digite exatamente: node calculadora.js 10 + 5

    ❌ "Os valores devem ser números válidos"

    Causa: Você digitou algo que não é número (como letras).

    Solução: Use apenas números: node calculadora.js 15.5 * 2

    ❌ "Operação '+' não é válida"

    Causa: No Windows, alguns símbolos precisam de aspas.

    Solução: Use aspas: node calculadora.js 10 "*" 5

    ✅ Código Completo da Solução
    // 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)}`);
    }
    🎉 Exemplos de Uso:
    $ 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

    📝 Exercício 3: Package.json Personalizado

    Nível: Iniciante | Tempo estimado: 10 minutos

    🎯 O que você vai aprender:

    • Como criar um package.json personalizado
    • Configurar scripts customizados
    • Definir metadados do projeto
    • Organizar comandos úteis
    • Entender a estrutura JSON

    📋 Descrição do Exercício

    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!

    🏪 Cenário: Padaria Doce Sabor

    Sua padaria precisa de um sistema que tenha:

    • Um comando para iniciar o sistema principal
    • Um comando para desenvolvimento (que reinicia automaticamente)
    • Um comando para ver informações do sistema
    • Um comando para usar a calculadora

    🛠️ Passo a Passo

    Passo 1: Criar o arquivo package.json

    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.

    Passo 2: Estrutura básica

    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.

    Passo 3: Informações básicas do projeto

    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:

    • name: Nome do projeto (sem espaços, use hífens)
    • version: Versão atual (formato: major.minor.patch)
    • description: Breve descrição do que o projeto faz
    • main: Arquivo principal que será executado
    • author: Quem criou o projeto
    • license: Tipo de licença (MIT é a mais comum)
    Passo 4: Adicionar scripts personalizados

    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 principal
    • npm run dev → Modo desenvolvimento (reinicia automaticamente)
    • npm run info → Mostra informações do sistema
    • npm run calc → Abre a calculadora
    Passo 5: Adicionar palavras-chave

    Para 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"
    }
    💡 Testando os Scripts

    Depois de criar o package.json, você pode testar os comandos:

    Testar o comando info:
    npm run info

    Deve executar o script sistema.js que você criou no exercício 1

    Testar a calculadora:
    npm run calc 10 + 5

    Deve executar a calculadora com os argumentos 10 + 5

    🚨 Troubleshooting - Problemas Comuns
    ❌ "Unexpected token in JSON"

    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.

    ❌ "npm: command not found"

    Causa: NPM não está instalado ou não está no PATH.

    Solução: Reinstale o Node.js (que inclui o NPM automaticamente).

    ❌ "Script not found"

    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.

    ✅ Código Completo da Solução
    {
      "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"
      }
    }
    🎉 Comandos Disponíveis:

    npm start - Inicia o sistema principal

    npm run dev - Modo desenvolvimento

    npm run info - Informações do sistema

    npm run calc 10 + 5 - Calculadora

    🎉 Parabéns! Você Concluiu a Aula 1!

    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.

    📚 O Que Você Aprendeu Hoje

    Conceitos Fundamentais
    • Node.js: O que é e como funciona
    • Event Loop: Como o Node.js processa tarefas
    • JavaScript no Servidor: Diferenças do navegador
    • Terminal/Prompt: Como navegar e executar comandos
    Habilidades Práticas
    • Instalar Node.js: Em qualquer sistema operacional
    • Criar Scripts: Arquivos .js executáveis
    • Usar Módulos: os, process e outras APIs
    • Gerenciar Projetos: package.json e NPM

    Sistema de Informações

    Script que mostra dados do computador usando módulos nativos do Node.js

    node sistema.js

    Calculadora Terminal

    Aplicação que processa argumentos da linha de comando para fazer cálculos

    node calc.js 10 + 5

    Projeto Organizado

    Package.json com scripts personalizados para gerenciar o projeto

    npm run info

    💡 Conceitos Importantes para Lembrar

    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.

    🚀 Preparando-se para a Aula 2

    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!

    O que você vai aprender:
    • Como criar um servidor HTTP básico
    • O que são rotas e como funcionam
    • Como servir páginas HTML pelo Node.js
    • Conceitos de requisição e resposta

    💡 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!

    Aula Anterior

    Esta é a primeira aula