CS Fundamentals Trainer · Guias

Git: desfazendo erros com reflog, reset, revert, rebase e recuperação

Um guia prático para sair de apuros no Git: as três áreas (árvore de trabalho, índice, repositório), o que cada modo do reset toca, o reflog como ferramenta de recuperação e seus limites, reset contra revert, amend e fixup com autosquash, rebase interativo, cherry-pick, conflitos de merge (zdiff3, rerere), stash, force-with-lease e como descobrir o que mudou.

9 min de leitura

A maioria das pessoas aprende Git como uma lista de comandos e trava na primeira vez que algo dá errado: um commit na branch errada, um reset --hard que levou uma tarde de trabalho, um merge cheio de marcadores de conflito. A saída é um modelo mental pequeno mais uma rede de segurança. O Git quase nunca destrói trabalho commitado; ele move ponteiros, e os commits antigos ficam no armazenamento de objetos por semanas. Este guia explica os três lugares onde suas mudanças vivem, os comandos que as movem, o reflog que permite desfazer quase tudo, como reescrever o histórico com segurança antes de compartilhá-lo, como tratar conflitos e como dar push sem prejudicar um colega. Toda saída de comando abaixo veio de uma execução real com Git 2.43. Para o modelo de objetos por trás (blobs, árvores, commits, refs) e para bisect, estratégias de branches e CI, veja o guia "Git internals and CI/CD pipelines".

1. Três lugares e quem mexe neles

Uma mudança passa por três áreas, e quase toda pergunta de desfazer é "qual área eu quero reiniciar?".

ÁreaO que éMovida por
Árvore de trabalhoos arquivos no discoseu editor, git restore, git switch, git stash
Índice (área de preparação)o instantâneo que o próximo commit vai registrargit add, git restore --staged, git reset
Repositóriocommits e o ponteiro de branch HEADgit commit, git reset, git revert, git rebase

git reset tem três modos que diferem apenas em até onde vão:

ComandoMove o ponteiro da branchReinicia o índiceSobrescreve a árvore de trabalho
git reset --soft <c>simnãonão
git reset --mixed <c> (padrão)simsimnão
git reset --hard <c>simsimsim

Só --hard (e git restore <arquivo>, git checkout -- <arquivo>, git clean) pode perder trabalho não commitado, porque esse trabalho nunca esteve no repositório. Tudo que foi commitado é recuperável, como a próxima seção mostra.

2. A rede de segurança: o reflog

Toda vez que HEAD ou uma branch se move, o Git escreve uma linha no reflog, um diário privado e local de por onde seus ponteiros passaram. Depois de um reset errado, os commits não sumiram, apenas deixaram de ser alcançáveis por qualquer branch:

$ git reset --hard HEAD~2
$ git log --oneline
0decb64 c1
$ git reflog
0decb64 HEAD@{0}: reset: moving to HEAD~2
2a2c20c HEAD@{1}: commit: c3
703d80e HEAD@{2}: commit: c2
0decb64 HEAD@{3}: commit (initial): c1
$ git reset --hard HEAD@{1}
$ git log --oneline
2a2c20c c3
703d80e c2
0decb64 c1

Lembre três fatos sobre ele:

Um HEAD destacado é o outro caso em que o reflog salva: commits feitos ali não pertencem a nenhuma branch, e git switch -c resgate <sha> dá um nome a eles.

3. Desfazendo uma mudança: reset ou revert?

$ git revert --no-edit HEAD
$ git log --oneline | head -2
0ad11db Revert "c3"
2a2c20c c3

Para reverter um commit de merge você precisa dizer qual lado manter com -m 1 (em geral a linha principal). Reverter um merge também faz o Git considerar essas mudanças já integradas, então mesclar a branch de novo depois não traz nada; é preciso reverter o revert antes.

Para arquivos individuais use os comandos mais novos e claros (Git 2.23): git restore <arquivo> descarta edições da árvore de trabalho, git restore --staged <arquivo> tira da preparação, e git restore --source=<commit> <arquivo> traz uma versão do passado. git switch troca de branch e git switch -c nome cria uma.

4. Consertando os últimos commits

Mensagem errada, ou esqueceu um arquivo: git commit --amend substitui o último commit (com as mudanças preparadas e uma nova mensagem). Isso muda o id do commit, então só use antes do push.

Uma correção que pertence a um commit anterior: commite com --fixup e deixe o Git reordenar:

$ git commit -qa --fixup HEAD
$ git log --oneline | head -2
3328826 fixup! feat g
9744119 feat g
$ GIT_SEQUENCE_EDITOR=true git rebase -i --autosquash HEAD~2
$ git log --oneline | head -2
3e798ea feat g
0ad11db Revert "c3"

O rebase interativo (git rebase -i <base>) abre uma lista de tarefas com uma linha por commit. Mude a palavra no início da linha:

PalavraEfeito
pickmanter o commit
rewordmanter, editar a mensagem
editparar aqui para você alterar o commit
squash / fixupjuntar ao commit anterior (fixup descarta a mensagem)
dropremover o commit

Reordenar linhas reordena commits. Se algo der errado, git rebase --abort volta ao estado anterior ao início, e o reflog tem a ponta original.

5. Movendo um commit entre branches

git cherry-pick <sha> copia um commit para a branch atual como um novo commit (novo id, mesma mudança). Use para um hotfix que precisa chegar a duas branches, ou quando você commitou na branch errada: faça cherry-pick na certa e depois git reset --hard HEAD~1 na errada. Vários commits de uma vez: git cherry-pick A..B. Um commit cherry-picked pode ter conflito como qualquer merge, e o Git não saberá que dois commits são "a mesma mudança", então evite cherry-pick de algo que você vai mesclar depois.

6. Conflitos de merge

Um conflito acontece quando os dois lados mudaram as mesmas linhas. O Git para, marca os arquivos e espera:

<<<<<<< HEAD
B
=======
A
>>>>>>> a

Edite o arquivo para o resultado que quer, remova os marcadores, faça git add e termine com git commit (ou git rebase --continue em um rebase). Se quiser sair: git merge --abort ou git rebase --abort, e a árvore de trabalho volta ao que era.

Três configurações facilitam os conflitos:

O rebase resolve conflitos commit a commit e pode repetir o mesmo conflito; o merge os resolve uma vez, no fim.

7. Stash: pondo o trabalho de lado

git stash guarda arquivos rastreados modificados e limpa a árvore de trabalho; git stash pop os restaura (e remove a entrada), git stash list os mostra, e git stash -u inclui arquivos não rastreados. Serve para interrupções curtas, como trocar de branch para uma correção rápida. Para qualquer coisa que dure mais de uma hora, um commit de trabalho em andamento em uma branch é mais seguro que um stash: stashes não têm branch, são fáceis de esquecer e podem dar conflito ao serem aplicados.

8. Enviando um histórico que você reescreveu

Depois que um commit foi enviado e outras pessoas podem tê-lo, reescrevê-lo obriga todo mundo a consertar suas branches. Portanto: reescreva à vontade as suas próprias branches não compartilhadas, e nunca force push em uma branch compartilhada como main. Quando precisar atualizar sua própria branch de funcionalidade depois de um rebase, use:

git push --force-with-lease

Ele só sobrescreve a branch remota se ela ainda aponta para onde você a viu por último, então você não apaga um commit que um colega enviou nesse meio tempo. O --force simples não tem essa verificação. Muitas equipes protegem a main com regras de branch que rejeitam force push por completo.

9. Descobrindo o que aconteceu

Algumas exclusões seguras: git branch -d nome se recusa a apagar uma branch não mesclada ("error: the branch 'dead' is not fully merged"), e -D força. Os commits continuam no reflog se você se arrepender.

10. Erros comuns

  1. Rodar reset --hard ou clean -fd com trabalho não commitado que você queria.
  2. Fazer amend ou rebase de commits já enviados a uma branch compartilhada.
  3. git push --force em vez de --force-with-lease.
  4. Usar revert para um erro privado (ruído) ou reset para um compartilhado (quebra os colegas).
  5. Resolver um conflito escolhendo um lado às cegas em vez de ler os dois.
  6. Entrar em pânico após um comando errado em vez de ler o git reflog.
  7. Commits enormes de "corrigir tudo", impossíveis de reverter ou de bisseccionar.
  8. Commitar segredos e apagá-los em um commit posterior: eles continuam no histórico. Troque o segredo e reescreva o histórico se necessário.

11. O que mencionar em uma entrevista

Resumo rápido

O Git move ponteiros; os commits sobrevivem. Confira git status, commite antes de operações arriscadas e use git reflog quando achar que perdeu trabalho. reset para histórico privado, revert para histórico compartilhado, --force-with-lease se precisar sobrescrever sua própria branch, e nunca force push em branches compartilhadas.

Fontes

Pratique este tema: DevOps & Cloud

Mais guias