Terminal para Iniciantes

Por que você precisa dominar o terminal?

Antes de mergulharmos, deixe-me responder a pergunta que todo iniciante faz:

• IDEs fazem tudo isso, não é? Sim, mas nem sempre. Muitas tarefas são muito mais rápidas no terminal.
• Faz parecer que sou hacker? Não, mas faz você parecer que sabe o que está fazendo (e você vai saber).
• É difícil? Não. É só prática. Como tudo em programação.

Os 15 Comandos Essenciais

Aqui está a tabela de referência rápida. Depois, vou detalhar cada um com exemplos práticos:

Comando	O que faz	Quando usar
ls	Lista arquivos e pastas	Explorar diretórios
cd	Muda de pasta	Navegar até um projeto
pwd	Mostra pasta atual	Confirmar onde você está
mkdir	Cria nova pasta	Criar estrutura de projeto
touch	Cria arquivo vazio	Iniciar novo arquivo
cp	Copia arquivos	Duplicar arquivos ou pastas
mv	Move ou renomeia	Reorganizar arquivos
rm	Deleta arquivos	Remover arquivos (cuidado!)
cat	Mostra conteúdo do arquivo	Ler arquivo no terminal
grep	Busca por texto	Encontrar padrões em arquivos
find	Localiza arquivos	Buscar por nome ou tipo
chmod	Muda permissões	Fazer arquivo executável
sudo	Executa com privilégios	Tarefas que precisam permissão
npm / pip / git	Gerenciadores de pacotes	Instalar dependências, versionamento
clear	Limpa a tela	Organizar visual do terminal

1. Navegação: Conhecendo o Seu Ambiente

pwd – Onde estou agora?

$ pwd
/Users/seu-usuario/projetos/meu-app

Quando usar: Quando você abrir um terminal novo e não tiver certeza de onde está. Use isso sempre que ficar confuso.

ls – O que tem nessa pasta?

# Lista tudo
$ ls
Desktop    Documents    Downloads    projetos

# Com mais detalhes
$ ls -la
total 64
drwxr-xr-x  12 user  staff   384 Apr  8 14:23 .
drwxr-xr-x   5 root  wheel   160 Apr  1 09:15 ..
-rw-r--r--   1 user  staff  6148 Apr  8 14:23 .DS_Store
drwxr-xr-x  15 user  staff   480 Apr  8 12:31 projetos

# Apenas arquivos de um tipo
$ ls *.js
app.js    server.js    config.js

Quando usar: Sempre que precisar entender o que tem em uma pasta. ls -la mostra tudo, inclusive arquivos ocultos.

cd – Entrar em uma pasta

# Entrar em uma pasta
$ cd projetos

# Voltar para a pasta anterior
$ cd ..

# Voltar para a home
$ cd ~

# Entrar em um caminho completo
$ cd /Users/seu-usuario/projetos/meu-app

# Entrar na pasta anterior onde estava
$ cd -

Quando usar: Todo dia, várias vezes. É como abrir uma pasta no Finder/Explorador.

2. Criação e Manipulação de Arquivos

mkdir – Criar uma nova pasta

# Criar uma pasta
$ mkdir meu-projeto

# Criar múltiplas pastas aninhadas de uma vez
$ mkdir -p src/components src/pages src/styles

Quando usar: Ao estruturar um novo projeto. O -p é especialmente útil para criar estruturas inteiras.

touch – Criar um arquivo vazio

# Criar um arquivo vazio
$ touch index.html

# Criar múltiplos arquivos
$ touch style.css script.js

Quando usar: Para iniciar novos arquivos rapidamente, sem abrir editor.

cat – Ler arquivo no terminal

# Ver o conteúdo completo
$ cat README.md

# Ver várias linhas de um arquivo grande
$ head -20 arquivo-grande.txt
$ tail -10 arquivo-grande.txt

# Ver com números de linha
$ cat -n app.js | head -30

Quando usar: Para conferir rapidamente o conteúdo de um arquivo sem abrir em editor.

3. Movimentação e Organização

cp – Copiar arquivos

# Copiar um arquivo
$ cp config.js config-backup.js

# Copiar pasta inteira (com -r = recursive)
$ cp -r src src-backup

# Copiar para outro diretório
$ cp index.html ~/projetos/outro-app/

Quando usar: Fazer backup, duplicar estruturas, copiar arquivos entre projetos.

mv – Mover ou renomear

# Renomear arquivo
$ mv index.html home.html

# Mover para pasta diferente
$ mv app.js src/

# Mover e renomear ao mesmo tempo
$ mv old-name.js src/new-name.js

# Mover pasta inteira
$ mv src-old src-new

Quando usar: Reorganizar projeto, renomear arquivos em massa, mover arquivos.

rm – Deletar arquivos (⚠️ Cuidado!)

# Deletar arquivo (sem confirmação!)
$ rm arquivo-temporario.txt

# Deletar pasta inteira (com -r = recursive)
$ rm -r node_modules/

# Deletar com confirmação (mais seguro)
$ rm -i arquivo.js
# Remove arquivo.js? y

# Deletar tudo que corresponde a um padrão
$ rm *.log

Quando usar: Limpeza de arquivos, remover node_modules, limpar arquivos temporários.

⚠️ AVISO: Não há "Lixeira" no terminal. Uma vez deletado, sumiu para sempre. Use rm -i para confirmar antes.

4. Busca e Localização

find – Localizar arquivos

# Encontrar arquivo por nome
$ find . -name "*.js"
./src/app.js
./src/server.js
./tests/unit.js

# Encontrar em pasta específica
$ find src/ -name "*.js"

# Encontrar por tipo
$ find . -type f -name "*.json"
$ find . -type d -name "node_modules"

# Encontrar e deletar (seja cuidadoso!)
$ find . -name "*.log" -delete

Quando usar: Procurar arquivos quando não sabe exatamente onde estão, encontrar todos os arquivos de um tipo.

grep – Buscar por texto dentro de arquivos

# Buscar por texto em arquivo
$ grep "function calcular" app.js
17: function calcularTotal() {

# Buscar em múltiplos arquivos
$ grep -r "TODO" src/
src/app.js: // TODO: implementar autenticação
src/pages/login.js: // TODO: validar formulário

# Buscar sem diferenciar maiúsculas/minúsculas
$ grep -i "error" log.txt

# Mostrar linhas antes e depois
$ grep -C 2 "erro" log.txt

Quando usar: Encontrar onde uma função está definida, procurar por "TODO"s no código, localizar erros em logs.

5. Manipulação de Permissões

chmod – Mudar permissões (especialmente para executáveis)

# Tornar arquivo executável
$ chmod +x script.sh

# Remover permissão de escrita
$ chmod -w arquivo.txt

# Usar modo numérico (755 = rwxr-xr-x)
$ chmod 755 deploy.sh
$ chmod 644 config.json

Quando usar: Quando precisa executar um script shell, configurar permissões de arquivo.

sudo – Executar com privilégios de administrador

# Instalar algo que precisa permissão
$ sudo npm install -g @angular/cli

# Editar arquivo de sistema
$ sudo nano /etc/hosts

# Executar script como admin
$ sudo ./deploy.sh

Quando usar: Quando um comando é bloqueado por falta de permissão. Use com moderação.

6. Gerenciadores de Pacotes e Versionamento

npm – Node Package Manager (para JavaScript)

# Inicializar novo projeto
$ npm init -y

# Instalar dependência
$ npm install express

# Instalar dependência de desenvolvimento
$ npm install --save-dev jest

# Instalar versão específica
$ npm install react@18.2.0

# Atualizar dependências
$ npm update

# Ver o que está instalado
$ npm list

# Remover pacote
$ npm uninstall axios

Quando usar: Todo dia se trabalha com JavaScript/Node.js.

pip – Python Package Manager

# Instalar pacote
$ pip install numpy

# Instalar de requirements
$ pip install -r requirements.txt

# Listar pacotes instalados
$ pip list

# Criar arquivo de dependências
$ pip freeze > requirements.txt

Quando usar: Toda vez que trabalha com Python.

git – Versionamento (muitíssimo importante)

# Clonar repositório
$ git clone https://github.com/usuario/projeto.git

# Ver status do projeto
$ git status

# Adicionar mudanças
$ git add .
$ git add arquivo-especifico.js

# Fazer commit
$ git commit -m "Adiciona nova funcionalidade de login"

# Ver histórico
$ git log

# Enviar para repositório remoto
$ git push origin main

# Atualizar local com remoto
$ git pull

# Criar nova branch
$ git checkout -b feature/nova-funcionalidade

# Trocar de branch
$ git checkout main

Quando usar: Em todo projeto com controle de versão (que é praticamente todo projeto).

7. Limpeza e Utilidade

clear – Limpar a tela

$ clear

Ou pressione Ctrl + L — atalho equivalente.

Quando usar: Quando a tela fica muito poluída e você quer começar do zero.

Exemplos de Uso Real: Cenários que Você Vai Enfrentar

Cenário 1: Novo Projeto React

# Chegar em casa, abrir terminal
$ pwd
/Users/você

# Ir para pasta de projetos
$ cd projetos

# Criar novo app React
$ npx create-react-app meu-app

# Entrar na pasta
$ cd meu-app

# Ver estrutura criada
$ ls -la

# Abrir em editor (assumindo VS Code)
$ code .

# Ou iniciar o servidor de desenvolvimento
$ npm start

Cenário 2: Encontrar e Corrigir um Bug em Log

# Ver últimas 50 linhas do log
$ tail -50 error.log

# Procurar por "erro de autenticação"
$ grep -i "autenticação" error.log

# Procurar em todos os arquivos de log
$ grep -r "failed" logs/

# Ver com contexto (5 linhas antes e depois)
$ grep -B 5 -A 5 "401" error.log

Cenário 3: Limpeza de Projeto (remover node_modules)

# Ver o que tem na pasta
$ ls -la

# Confirmar que node_modules existe
$ find . -name "node_modules" -type d

# Deletar (de verdade, vai sumir!)
$ rm -r node_modules

# Reinstalar depois
$ npm install

# Ou tudo em um bash script
$ rm -r node_modules && npm install

Cenário 4: Backup Rápido de Projeto

# Copiar projeto inteiro
$ cp -r meu-app meu-app-backup

# Ou criar um arquivo compactado
$ tar -czf meu-app-backup.tar.gz meu-app

# Depois: descompactar se precisar
$ tar -xzf meu-app-backup.tar.gz

Cenário 5: Deploy com Git

# Verificar status
$ git status

# Ver todas as mudanças
$ git diff

# Adicionar tudo
$ git add .

# Fazer commit com mensagem clara
$ git commit -m "Corrige bug no formulário de login"

# Enviar para produção (branch main)
$ git push origin main

# Ver histórico
$ git log --oneline | head -10

Dicas e Truques para Usar Terminal de Verdade

Quer aprofundar no Git? Veja o guia completo em O que é Git e por que todo dev precisa saber.

1. Use setas para histórico

Pressione seta para cima para voltar aos comandos anteriores. Não precisa digitar tudo de novo.

2. Use Tab para autocompletar

Comece a digitar um comando e pressione Tab. O terminal completa automaticamente.

$ cd pro[TAB] → cd projetos/

3. Use && para encadear comandos

Execute vários comandos de uma vez:

$ cd meu-app && npm install && npm start

4. Use | (pipe) para passar saída de um comando para outro

$ grep -r "TODO" src/ | wc -l  # Conta quantos TODOs existem
$ ls -la | grep ".js"  # Lista apenas arquivos .js

5. Use . para "pasta atual" e ~ para "home"

$ cp ~/Downloads/arquivo.pdf .  # Copia do Downloads para pasta atual
$ ls ~/Documentos  # Lista sem sair da pasta atual

6. Histórico com Ctrl + R

Ctrl + R → [digita parte do comando] → encontra comando anterior

Armadilhas Comuns (e como evitar)

❌ rm -rf / ou rm -rf /pasta

Não faça isso. Não existe "desfazer".

❌ Esquecer o -r ao deletar pasta

$ rm node_modules  # ❌ ERRO
$ rm -r node_modules  # ✅ CORRETO

❌ sudo em tudo

Só use sudo quando realmente precisar. Não é necessário para npm, git, etc.

❌ Não fazer git commit regularmente

Faça commit frequente. Um commit por feature, não um por linha de código.

$ git commit -m "Implementa sistema completo de autenticação"  # ✅ Bom
$ git commit -m "adiciona variável"  # ❌ Ruim

Próximos Passos

Agora que você sabe os 15 comandos essenciais, próximas habilidades para aprender:

1. Bash scripting – Automatize tarefas repetitivas
2. SSH – Conecte em servidores remotos
3. Docker – Containers e ambientes isolados
4. Makefile – Organize comandos complexos

Exercício Prático

Tente isso agora (em uma pasta segura):

# 1. Crie uma pasta chamada "teste-terminal"
$ mkdir teste-terminal

# 2. Entre nela
$ cd teste-terminal

# 3. Crie alguns arquivos
$ touch app.js style.css index.html

# 4. Liste o que criou
$ ls -la

# 5. Renomeie app.js para main.js
$ mv app.js main.js

# 6. Veja se renomeou
$ ls

# 7. Delete o arquivo style.css
$ rm style.css

# 8. Veja o resultado
$ ls

# 9. Volte para a pasta anterior
$ cd ..

# 10. Delete a pasta de teste
$ rm -r teste-terminal

Se conseguiu fazer tudo isso sem erros, parabéns! Você já está bem mais confortável com o terminal.

Conclusão

O terminal não é mais assustador do que parece. Com esses 15 comandos, você consegue:

✅ Navegar por seu computador ✅ Criar e organizar arquivos ✅ Gerenciar dependências ✅ Clonar e fazer deploy de código ✅ Procurar por informações ✅ Resolver a maioria dos problemas do dia a dia

O resto é prática. Use o terminal todo dia, e em uma semana já vai parecer natural.

E lembre-se: todo dev que você admira começou exatamente onde você está agora. A diferença é que eles não desistiram.

Agora saia do medo e entra no terminal 💪

---

Referência Rápida (Resumo em um colinha)

# NAVEGAÇÃO
pwd                 # Onde estou?
ls, ls -la          # Listar arquivos
cd pasta            # Entrar em pasta
cd ..               # Voltar
cd ~                # Ir para home

# CRIAÇÃO
mkdir pasta         # Criar pasta
touch arquivo.txt   # Criar arquivo
mkdir -p a/b/c      # Criar aninhado

# MANIPULAÇÃO
cp arquivo cópia    # Copiar
mv arquivo novo-nome # Mover/renomear
rm arquivo          # Deletar arquivo
rm -r pasta         # Deletar pasta

# BUSCA
find . -name "*.js" # Procurar arquivo
grep "texto" arq    # Procurar no arquivo

# PERMISSÕES
chmod +x script.sh  # Tornar executável

# PACOTES
npm install         # Instalar
pip install         # Python
git clone URL       # Clonar repositório

# LIMPEZA
clear               # Limpar tela

---