Diferenças, .gitignore e como desfazer

Errar faz parte de programar, e o Git existe em boa parte para que errar não seja grave. Esta aula mostra como inspecionar mudanças, manter lixo fora do repositório e desfazer coisas com segurança.

Vendo o que mudou: git diff

git diff              # mudanças ainda NÃO preparadas (diretório de trabalho)
git diff --staged     # mudanças já preparadas com git add (prontas para o commit)

O diff mostra linhas removidas (com -) e adicionadas (com +). Ele é o seu melhor amigo antes de commitar: olhar o diff evita levar para o histórico um print de depuração esquecido.

Para ver o histórico com mais detalhes:

git log                       # completo: autor, data, mensagem
git log --oneline             # resumido, um commit por linha
git show HASH                 # o que mudou em um commit específico

O HASH é o código de cada commit, que aparece no git log (os 7 primeiros caracteres já bastam).

Ignorando arquivos com .gitignore

Nem tudo deve ir para o repositório: dependências baixadas, arquivos temporários, ambientes virtuais e, principalmente, senhas e chaves. Liste esses padrões num arquivo chamado .gitignore na raiz do projeto:

# ambiente virtual e caches do Python
.venv/
__pycache__/
*.pyc

# dependências do Node
node_modules/

# variáveis de ambiente e segredos
.env

# arquivos do sistema
.DS_Store

Atenção

O .gitignore só afeta arquivos que ainda não estão sendo rastreados. Se você já commitou um arquivo e depois o adicionou ao .gitignore, ele continua no histórico. Para parar de rastrear sem apagar o arquivo do disco, use git rm --cached arquivo.

Desfazendo coisas

Cada situação pede um comando diferente. Esta tabela é o seu guia:

Situação	Comando
Descartar mudanças de um arquivo, ainda sem commit	`git restore arquivo`
Tirar um arquivo da área de preparação (desfazer o `add`)	`git restore --staged arquivo`
Corrigir o último commit (mensagem ou arquivo esquecido)	`git commit --amend`
Desfazer um commit criando outro commit que o inverte	`git revert HASH`

Atenção

git restore arquivo apaga suas mudanças não commitadas daquele arquivo, e elas não voltam. Já o git commit --amend reescreve o histórico, então só use em commits que ainda não foram enviados a ninguém. Para commits já compartilhados, prefira o git revert, que é seguro porque não apaga nada, só adiciona um commit de correção.

Existe também o git reset --hard, que joga fora commits e mudanças de uma vez. Ele é poderoso e perigoso: evite usá-lo até entender bem o que faz.

Guardando trabalho pela metade: git stash

Às vezes você está no meio de uma mudança e precisa trocar de assunto, sem commitar algo incompleto. O stash guarda as mudanças numa gaveta:

git stash            # guarda as mudanças e deixa o diretório limpo
# ... faz o que precisava ...
git stash pop        # traz as mudanças de volta

Exercícios

Exercício

1. Aquecimento. Edite um arquivo já commitado, rode git diff para ver a mudança, prepare com git add e rode git diff --staged. O que cada comando mostrou?

Exercício

2. Ignorando. Crie um arquivo .env com SENHA=123 e uma pasta __pycache__ com um arquivo qualquer dentro. Crie o .gitignore certo e confirme, com git status, que nenhum dos dois aparece como arquivo a ser commitado.

Exercício

3. Desafio. Faça um commit com uma mensagem errada, corrija-a com git commit --amend. Depois faça um segundo commit com um bug de propósito e desfaça-o com git revert. Compare o git log --oneline de antes e depois: em qual dos dois casos o histórico ficou com um commit a mais?