Git rebase: rebase vs merge, rebase interativo e como desfazer

Guia de git rebase

Git rebase: rebase vs merge, rebase interativo, desfazer | We.Inc

Veja rebase e merge lado a lado em um grafo de commits ao vivo, planeje um rebase interativo com pick, squash, fixup e drop e aprenda a abortar ou desfazer com o reflog.

git rebase reaplica os commits do seu branch em cima de outro commit, gerando um histórico linear em vez de um merge commit. Rode git rebase main a partir do seu branch de feature, resolva os conflitos e depois rode git rebase --continue. Use git rebase -i para juntar, reescrever ou descartar commits, e git rebase --abort para voltar atrás.

Os comandos de rebase que você mais vai digitar

Objetivo
Comando

Mover seu branch para a main mais recente
git rebase main

Editar os últimos 4 commits
git rebase -i HEAD~4

Continuar depois de resolver um conflito
git add <file> then git rebase --continue

Pular o commit que travou
git rebase --skip

Cancelar e voltar ao estado anterior
git rebase --abort

Juntar commits fixup! automaticamente
git rebase -i --autosquash main

Rebase é o comando do git que mais assusta, principalmente porque ele reescreve commits. O grafo abaixo mostra exatamente o que muda quando você faz merge ou rebase, o planejador deixa você testar um rebase interativo em commits de exemplo, e as últimas seções tratam de conflitos, da única regra que protege seus colegas e de como recuperar um branch depois de um rebase que deu errado.

Alterne o grafo entre merge e rebase para ver onde os commits vão parar e quais ganham hashes novos.
No planejador, mude a ação de cada commit de exemplo e leia a todo list que o git abriria e o histórico que você teria no final.
Copie os comandos das tabelas para o seu próprio terminal; nada nesta página roda o git por você.
Se um rebase real der errado, siga a receita do reflog no final para restaurar a ponta antiga do branch.

Faça commit ou stash do seu trabalho antes de começar. Um rebase com a working tree suja se recusa a começar.
Depois de fazer rebase de um branch que você já enviou, use git push --force-with-lease em vez de --force puro, para não sobrescrever commits novos de um colega.
Crie commits de correção com git commit --fixup <hash> enquanto trabalha, e um único git rebase -i --autosquash arruma todos no final.
Defina git config --global rebase.autoStash true se você costuma esquecer de fazer stash antes.

Perguntas frequentes

Devo usar rebase ou merge?

O merge mantém o histórico real e adiciona um merge commit, o que é mais seguro para branches compartilhados. O rebase gera uma linha reta, mais fácil de ler e de usar com bisect, o que combina com o seu branch de feature antes da revisão. Muitos times fazem rebase no privado e merge no público.

Como desfaço um rebase?

Se ainda estiver em andamento, git rebase --abort volta tudo ao que era. Se já terminou, rode git reflog, encontre a entrada logo antes do início do rebase e faça git reset --hard para esse hash. ORIG_HEAD também aponta para a ponta antiga logo depois de um rebase, a menos que outro comando a tenha mudado.

Qual é a regra de ouro do rebase?

Não faça rebase de commits sobre os quais outras pessoas já basearam trabalho. O rebase cria commits novos com hashes novos, então quem tem os antigos acaba com histórico duplicado e conflitos confusos.

Qual é a diferença entre squash e fixup?

Os dois juntam um commit ao que está acima dele. squash abre o editor para você combinar as duas mensagens; fixup descarta a mensagem do commit absorvido e mantém a anterior. fixup -C mantém a mensagem do commit absorvido no lugar.

Por que o git rebase para com um conflito?

Cada commit é aplicado de novo sobre a nova base, e um commit que mexeu nas mesmas linhas que a base não pode ser aplicado automaticamente. Edite o arquivo, rode git add nele e rode git rebase --continue. Pode haver um conflito por commit reaplicado.

O que o rebase faz de verdade

O git encontra o commit onde seu branch e o destino se separaram, salva seus commits como patches, move seu branch para o destino e aplica os patches um de cada vez. O resultado parece que você começou seu trabalho hoje a partir da main mais recente.
Como cada commit reaplicado tem um pai diferente, ele ganha um hash diferente. Por isso um branch rebaseado precisa de force push, e por isso fazer rebase de histórico compartilhado causa problemas.

Recuperando um branch com o reflog

O reflog registra, localmente, todos os lugares para onde o HEAD e a ponta de cada branch já apontaram. Commits deixados para trás pelo rebase continuam acessíveis por ele, então nada se perde na hora.
O git apaga entradas do reflog durante a coleta de lixo: por padrão, entradas acessíveis depois de 90 dias e inacessíveis depois de 30 dias. Recupere um rebase ruim logo, não meses depois.

Comandos do rebase interativo

git rebase -i abre uma todo list com uma linha por commit, com o mais antigo no topo. Troque a palavra no início de uma linha, salve e feche o editor, e o git executa a lista de cima para baixo.

Comandos da todo list no git rebase -i

Comando
O que faz

Mantém o commit como está

Mantém o commit, mas edita a mensagem

Para depois deste commit para você alterá-lo ou dividi-lo

Junta ao commit de cima e combina as duas mensagens

Junta ao commit de cima e descarta esta mensagem

fixup -C
Junta ao commit de cima e usa a mensagem deste commit

Roda um comando de shell, por exemplo seus testes

Pausa aqui; continue com git rebase --continue

Remove o commit

label / reset / merge
Nomeia pontos e reconstrói merges (usado com --rebase-merges)

Move a ref de outro branch para este ponto (usado com --update-refs)

Um rebase completo, com conflitos

Atualizar um branch de feature sobre a main

Faça fetch antes para a main estar atualizada, faça o rebase, resolva qualquer conflito e depois envie o branch reescrito com segurança.

Desfazer um rebase concluído com o reflog

Encontre a linha logo antes do início do rebase e faça reset do branch de volta para ela.

Movendo um branch para outra base

--onto recebe três pontos: a nova base, a base antiga e o branch. Só os commits depois da base antiga são movidos.

Tirar um branch de cima de outro branch de feature

feature-b foi criado a partir de feature-a. Isto coloca só os commits próprios de feature-b em cima da main.

Adiciona formulário de login
Corrige erro de digitação no rótulo do formulário
Valida o campo de e-mail
WIP saída de depuração

Merge ou rebase: o que acontece com o histórico

Escolha como combinar os branches

Merge

Rebase

merge commit

O merge mantém F1 e F2 intactos e adiciona um commit novo com dois pais.

O rebase copia F1 e F2 para cima de M3. As cópias (marcadas com ') têm hashes novos; os originais ficam para trás.

Planejador de rebase interativo

Escolha uma ação para cada commit, do mais antigo ao mais novo, e veja a todo list e o resultado.

Ação para o commit {n}

Todo list que o git abre

Histórico depois do rebase

A primeira linha não pode ser squash nem fixup: não há commit acima dela para juntar.

Todos os commits foram descartados. O branch apontaria para a sua base.

inclui {n} commit(s) absorvido(s)

mensagem editada

Comece grátis · Sem cartão de crédito