Infra15 min de leitura
Descomplicando o Git: stash, amend, fetch, rebase e reflog
Git sem medo: git stash, git mv, commit --amend, fetch x pull, rebase x merge, rebase interativo, push --force-with-lease e o reflog pra desfazer quase tudo.

Você aí tem medo de usar o Git? O máximo que faz é git add, git commit e git push, e o resto dos comandos te assusta? Você não está sozinho.
O Git parece intimidante porque quase todo comando mexe num lugar diferente, e ninguém te mostra o mapa. Quando você entende onde cada comando age, ele deixa de ser um bicho de sete cabeças e vira uma ferramenta que te salva toda semana.
Publiquei a primeira versão deste post no Medium em 2023. Esta é a versão revisada: explicações melhores, alguns erros meus corrigidos e cada comando testado de novo.
Aqui eu explico os comandos que mais uso além do commit e do push, com exemplos que rodei de verdade num repositório de teste: git stash, git mv, git commit --amend, git fetch, git rebase (e o interativo) e, no fim, o git reflog, que desfaz quase qualquer erro.
TL;DR#
git stashguarda as mudanças que você ainda não commitou numa gaveta, egit stash popdevolve. Arquivo novo só entra com-u.git mvé atalho pramv+git add. O Git não guarda renomeação: ele deduz pelo conteúdo. Pra ver o histórico de um arquivo renomeado, usegit log --follow.git commit --amendtroca o último commit por um novo. Ótimo pra arquivo esquecido ou mensagem errada, desde que o commit ainda não tenha subido.git fetchsó baixa e atualiza aorigin/main. Não mexe no seu código. Ogit pulléfetch+merge(ourebase).git rebasereaplica os seus commits em cima de outra base e deixa o histórico em linha reta. O interativo (-i) junta, edita e reordena commits.- Reescreveu histórico que já subiu? Use
git push --force-with-lease, nunca--force(nem+branch). No meu teste, o+mainapagou o commit de uma colega sem avisar. - Deu ruim? O
git refloglista tudo o que o seuHEADfoi, egit reset --hard HEAD@{n}volta pra lá.
O mapa: onde cada comando mexe#
Antes dos comandos, o desenho que me fez entender o Git. Existem cinco lugares, e cada comando leva mudanças de um pro outro:
- Diretório de trabalho: os arquivos que você edita.
- Stash: uma gaveta pra guardar mudanças sem commitar.
- Index (ou staging): o que vai entrar no próximo commit, depois do
git add. - Repositório local: os seus commits, na sua máquina.
- Remoto: o GitHub (ou GitLab, Bitbucket). A sua máquina guarda uma cópia do que viu lá por último, a
origin/main.
Guarde esse mapa. Quase toda confusão com Git vem de achar que um comando mexe num lugar quando ele mexe em outro.
git stash: a gaveta#
Você está no meio de uma tarefa, com arquivos alterados, e precisa trocar de branch pra corrigir um bug urgente. Commitar o trabalho pela metade fica feio. O git stash guarda as mudanças numa gaveta e deixa o diretório limpo:
git stash push -m "wip: signup form"
git switch hotfix/login
# ...fix the bug, commit, push...
git switch feature/signup
git stash popUm detalhe que pega muita gente: arquivo novo, que o Git ainda não rastreia, não vai pra gaveta. No meu teste, depois do git stash, o arquivo novo continuou lá:
$ git stash push -m "wip: signup form"
Saved working directory and index state On main: wip: signup form
$ git status --short
?? draft.txtPra levar os arquivos novos junto, use -u (de --include-untracked):
git stash push -u -m "wip: signup form"O
git stash save "nome"que aparece em tutorial antigo está obsoleto. O jeito atual de dar nome égit stash push -m "nome".
pop ou apply?#
Os dois devolvem as mudanças da gaveta pro diretório de trabalho. A diferença é o que acontece com a gaveta:
git stash applyaplica e mantém o stash na lista. Útil pra aplicar a mesma mudança em mais de uma branch.git stash popaplica e apaga o stash da lista. É oapplyseguido degit stash drop.
Com uma exceção: se o pop der conflito, ele não apaga nada. O próprio Git avisa:
Auto-merging app.txt
CONFLICT (content): Merge conflict in app.txt
...
The stash entry is kept in case you need it again.Você resolve o conflito, e depois apaga o stash com git stash drop quando tiver certeza de que não precisa mais dele.
Outros comandos da gaveta:
git stash list # every stash, newest first: stash@{0}, stash@{1}...
git stash show -p stash@{1} # what is inside one of them
git stash pop stash@{1} # bring back a specific one
git stash drop stash@{1} # delete onegit mv: renomear e mover#
O git mv renomeia ou move arquivo e já deixa a mudança pronta pro commit:
git mv index.html home.html # rename
git mv index.html public/ # move
git mv scripts src/scripts # folders tooA primeira versão deste post dizia que o git mv existe pra "não perder o histórico". Eu mesma acreditava nisso, e não é bem assim. O Git não guarda renomeação. Ele guarda o conteúdo dos arquivos em cada commit e, na hora de mostrar, compara: se um arquivo sumiu e apareceu outro quase igual, ele conclui que foi renomeado.
Por isso, mv + git add -A dá exatamente o mesmo resultado. Testei os dois, e o git status mostra a mesma coisa:
$ git mv index.html home.html
$ git status --short
R index.html -> home.html
$ mv home.html start.html && git add -A
$ git status --short
R home.html -> start.htmlO R é o Git dizendo "detectei uma renomeação". O git mv só te poupa um passo.
E o histórico? O git log de um arquivo para na renomeação. Pra seguir o arquivo pelos nomes antigos, use --follow:
$ git log --oneline -- home.html
3b727de rename index to home
$ git log --oneline --follow -- home.html
3b727de rename index to home
a366c0e add index pageDica: renomeie num commit e altere o conteúdo em outro. Se você renomeia e reescreve metade do arquivo no mesmo commit, o Git pode não reconhecer que é o mesmo arquivo, e aí nem o --follow acha o histórico.
Mudou de ideia antes de commitar? É só renomear de volta com git mv home.html index.html.
git commit --amend: consertar o último commit#
"git amend" não existe como comando. O que existe é a opção --amend do git commit, que troca o último commit por um novo.
Esqueceu um arquivo:
git add forgotten-file.ts
git commit --amend --no-edit # same message, new contentErrou a mensagem:
git commit --amend -m "feat: rename the home page"O que pouca gente percebe é que o commit não é editado, é substituído. Repare no hash mudando a cada --amend no meu teste:
22b393b rename again # before
f5024f2 rename again # after --amend --no-edit
4c2a0e4 feat: rename the home page # after --amend -mPor isso a regra: só use --amend em commit que ainda não subiu. Se ele já está no remoto e alguém baixou, você vai precisar de push forçado (mais sobre isso no fim) e a pessoa vai ficar com um commit que não existe mais.
git fetch: olhar antes de trazer#
O git fetch baixa o que tem de novo no remoto e atualiza a origin/main, aquela cópia do remoto que fica na sua máquina. Ele não mexe na sua branch nem nos seus arquivos. É como ler as manchetes sem abrir o jornal.
$ git fetch origin
From ../origin
4c2a0e4..8d7de9d main -> origin/main
$ git status -sb
## main...origin/main [behind 1]
$ git log --oneline main..origin/main
8d7de9d feat: add the profile pageO main..origin/main lista os commits que estão no remoto e ainda não estão na sua main. Você vê o que chegou antes de decidir trazer.
E o git pull? É o fetch seguido de um merge (ou de um rebase, se você configurar). Ele baixa e já junta na sua branch, tudo de uma vez:
git pull # fetch + merge
git pull --rebase # fetch + rebaseEu prefiro fetch antes quando a branch é compartilhada ou quando passei dias sem atualizar. Dá pra ver o tamanho da mudança antes do conflito aparecer na cara.
Trazendo de outro repositório#
O fetch também funciona com qualquer remoto, não só o origin. Exemplo: você tem um fork e quer as novidades do projeto original. Adicione ele como um segundo remoto:
git remote add upstream https://github.com/original-author/project.git
git fetch upstream
git merge upstream/mainupstream é só um apelido, como o origin. Depois é resolver os conflitos (se houver), commitar e dar push no seu fork.
git rebase: reaplicar os commits em outra base#
Você criou uma branch, fez dois commits, e enquanto isso alguém subiu um commit novo na main. Pra trazer o que entrou na main, existem dois caminhos:
git mergecria um commit de merge que junta as duas histórias. Nada é reescrito.git rebasepega os seus commits e reaplica um por um em cima damainnova, como se você tivesse começado a branch agora. O histórico fica em linha reta.
No meu teste, a main local tinha dois commits que a origin/main não tinha, e a origin/main tinha um que eu não tinha:
* 0df7909 wip
* 6f1f89e add z
| * 8d7de9d feat: add the profile page (origin/main)
|/
* 4c2a0e4 feat: rename the home pageDepois de git rebase origin/main:
* 2b2bea3 wip
* 4f1c163 add z
* 8d7de9d feat: add the profile page
* 4c2a0e4 feat: rename the home pageOs meus dois commits foram pra cima, em linha reta, com hashes novos (0df7909 virou 2b2bea3). Isso é o ponto principal do rebase: ele não move commits, ele cria commits novos com o mesmo conteúdo.
Qual usar? Um não é melhor que o outro, e muito time escolhe um como padrão. A regra que importa é uma só: não faça rebase de commits que outras pessoas já baixaram. Na sua branch, antes de abrir o PR, fique à vontade.
Rebase interativo: arrumar os commits antes do PR#
O git rebase -i abre uma lista com os commits e deixa você dizer o que fazer com cada um:
git rebase -i HEAD~3 # the last 3 commitspick 4f1c163 # add z
pick 2b2bea3 # wip
pick 060be7b # fix typo
# Rebase 8d7de9d..060be7b onto 8d7de9d (3 commands)Embaixo dessa lista o próprio Git explica os comandos. Os que eu mais uso:
pick: mantém o commit como está.reword: mantém, mas abre o editor pra mudar a mensagem.edit: para nesse commit pra você mudar o que quiser (arquivos, autor) e depoisgit rebase --continue.squash: junta no commit de cima e combina as mensagens.fixup: junta no commit de cima e descarta a mensagem deste.drop: apaga o commit.
Você troca a palavra na frente de cada linha, salva e fecha. Pra juntar o wip e o fix typo no commit de cima, por exemplo:
pick 4f1c163 # add z
fixup 2b2bea3 # wip
fixup 060be7b # fix typoPra editar várias mensagens, troque pick por reword. O Git vai parando em cada uma e abrindo o editor.
Se o editor não abre (ou abre o Vim e você não sabe sair), configure o VS Code:
git config --global core.editor "code --wait"O --wait faz o Git esperar você fechar a aba antes de continuar.
Commits com o nome ou o e-mail errado#
Clássico de computador novo: você esqueceu de configurar o user.name e o user.email, e os commits saíram como root@localhost. Primeiro, configure:
git config --global user.name "Your Name"
git config --global user.email "you@example.com"Depois, pra corrigir só o último commit:
git commit --amend --no-edit --reset-authorPra corrigir vários, em vez de marcar edit um por um como eu fazia, use o --exec, que roda um comando depois de cada commit reaplicado:
git rebase origin/main --exec "git commit --amend --no-edit --reset-author"Repare no origin/main em vez de HEAD~10. Ele pega só os commits que ainda não estão no remoto, ou seja, só os seus. No meu teste, eu usei HEAD~2 e um dos dois era o commit de uma colega, que já estava no remoto. O rebase trocou o autor dele pelo meu sem perguntar. Contar commits com HEAD~n é fácil de errar. Usar a base certa, não.
Push forçado sem apagar o trabalho dos outros#
Todo comando que reescreve histórico (--amend, rebase) cria commits novos. Se os antigos já estavam no remoto, o git push normal é recusado, porque o remoto teria que jogar commits fora. Aí entra o push forçado.
A primeira versão deste post sugeria git push origin +nome-da-branch. O + faz o mesmo que --force: sobrescreve o remoto com a sua versão, sem perguntar o que tem lá. Fiz o teste: uma colega subiu um commit na branch enquanto eu reescrevia a minha. Com o +main, o push passou, e o commit dela sumiu do remoto:
$ git push origin +main
+ c0a4ca7...db2256b main -> main (forced update)Com --force-with-lease, o mesmo push foi recusado:
$ git push --force-with-lease origin main
! [rejected] main -> main (stale info)
error: failed to push some refs to '../origin.git'O --force-with-lease só sobrescreve se o remoto ainda estiver igual à última versão que você viu (a sua origin/main). Se alguém subiu algo nesse meio tempo, ele recusa, e você faz git fetch, traz o commit da pessoa e tenta de novo.
Um cuidado: se você rodar git fetch logo antes, a sua origin/main já está atualizada, e o lease deixa passar mesmo sem você ter incorporado o commit da pessoa. Pra fechar esse buraco existe o --force-if-includes, que confere se o que está no remoto também está na sua branch. Testei: depois de um git fetch, o --force-with-lease sozinho passou por cima do commit novo da colega, e com o --force-if-includes junto o push foi recusado:
$ git push --force-with-lease --force-if-includes origin main
! [rejected] main -> main (remote ref updated since checkout)Vale um alias pra não digitar isso toda vez:
git config --global alias.pushf "push --force-with-lease --force-if-includes"
git pushfE a regra de sempre: push forçado na sua branch, tudo bem. Na main compartilhada, combine com o time antes (ou deixe a main protegida no GitHub).
git reflog: o desfazer do Git#
Fez um rebase que deu errado? Um reset --hard no lugar errado? Calma. Quase nada se perde de verdade no Git. O git reflog guarda cada lugar por onde o seu HEAD passou, inclusive commits que não aparecem mais no git log:
$ git reflog -6
9eadb5e HEAD@{0}: rebase (finish): returning to refs/heads/main
9eadb5e HEAD@{1}: commit (amend): add z
3a8f3fa HEAD@{2}: rebase (pick): add z
f7db88b HEAD@{3}: commit (amend): feat: add the profile page
8d7de9d HEAD@{4}: rebase (start): checkout HEAD~2
fba2c8f HEAD@{5}: rebase (finish): returning to refs/heads/mainFoi assim que eu desfiz o rebase que trocou o autor do commit da colega. O HEAD@{5} era o estado antes dele, então:
git reset --hard HEAD@{5}E tudo voltou como estava. Antes de qualquer operação que te dê medo, você também pode criar uma branch de segurança, que custa zero:
git branch backup/before-rebaseSe der errado, a branch está lá, apontando pro commit de antes.
O reflog é local e não é eterno: por padrão, entradas de commits que não estão em nenhuma branch expiram em 30 dias. E mudança que nunca foi commitada nem guardada no stash, o reflog não tem como salvar.
Resumo pra colar do lado do monitor#
| Quero... | Comando |
|---|---|
| Guardar o que não commitei e limpar o diretório | git stash push -u -m "name" |
| Trazer de volta da gaveta | git stash pop |
| Renomear um arquivo | git mv old new |
| Ver o histórico de um arquivo renomeado | git log --follow -- file |
| Adicionar um arquivo esquecido no último commit | git add file && git commit --amend --no-edit |
| Ver o que chegou no remoto, sem mexer em nada | git fetch && git log main..origin/main |
| Atualizar a minha branch em linha reta | git rebase origin/main |
| Juntar ou editar commits antes do PR | git rebase -i origin/main |
| Subir histórico reescrito sem apagar o de ninguém | git push --force-with-lease |
| Desfazer uma besteira | git reflog e git reset --hard HEAD@{n} |
Conclusão#
Viu só como não é um bicho de sete cabeças? Quando você enxerga os cinco lugares (diretório, stash, index, repositório local e remoto), cada comando vira só uma seta entre eles. E com o reflog no bolso, errar deixa de dar medo, porque quase tudo tem volta.
Quer praticar sem risco? Crie uma pasta, rode git init e faça todos os exemplos deste post nela. Foi assim que eu testei cada comando daqui.
Referências#
Leia também

Infra11 min de leitura
Datadog do zero: como integrar e como ler o painel

Infra15 min de leitura
Como economizar tokens no Claude Code com rtk e graphify

Infra13 min de leitura
Arquivo apagado não some: antes de vender seu HD ou SSD