Git Rebase para Iniciantes: Uma Introdução Simples

Introdução

Se você já olhou para o seu histórico do Git e pensou “isso é uma bagunça”, você não está sozinho. Essas linhas de branch entrelaçadas e commits de merge redundantes tornam difícil entender o que realmente mudou e quando. É aqui que o git rebase entra—uma ferramenta poderosa que ajuda você a manter um histórico de commits limpo e legível.

Neste guia, você aprenderá o que o rebase faz, como ele difere do merge, e quando usá-lo no seu fluxo de trabalho diário. Vamos focar em exemplos práticos que você pode começar a usar hoje, destacando as principais armadilhas a evitar.

O que é Git Rebase?

Pense no git rebase como reescrever a história—mas de uma forma boa. Quando você faz rebase, está pegando commits de um branch e reproduzindo-os em cima de outro branch, como se tivesse começado seu trabalho de um ponto diferente.

Imagine que você está escrevendo uma história. Você começa o capítulo 3 enquanto seu colega ainda está editando o capítulo 2. Quando ele termina, você poderia:

• Fazer merge: Adicionar uma nota dizendo “inseridas mudanças do capítulo 2 do colega aqui”
• Fazer rebase: Reescrever seu capítulo 3 como se tivesse começado depois que o capítulo 2 já estava completo

A abordagem de rebase oferece uma narrativa mais limpa sem o “ruído do merge.”

Por que Usar Git Rebase?

Mantendo o Histórico Linear e Limpo

Um histórico linear lê como um livro—um commit segue outro em uma sequência clara. Isso torna mais fácil:

• Rastrear quando bugs foram introduzidos
• Entender a evolução das funcionalidades
• Revisar mudanças de código em pull requests

Sem rebase, seu histórico se enche de commits de merge que dizem “Merged branch ‘main’ into feature-xyz” repetidamente, obscurecendo o trabalho real sendo feito.

Quando Desenvolvedores Escolhem Rebase

Desenvolvedores recorrem ao rebase em duas situações principais:

1. Manter-se atualizado: Seu branch de feature precisa das últimas atualizações do main
2. Polir o trabalho: Você quer limpar commits antes que outros os revisem

Ambos os cenários ajudam a manter aquele histórico limpo e linear que torna a vida de todos mais fácil.

Git Rebase vs Merge: As Principais Diferenças

Aqui está a diferença fundamental:

Merge cria um novo commit que combina dois branches:

A---B---C (main)
     \   \
      D---E---M (your-feature)

Rebase reproduz seus commits em cima do branch de destino:

A---B---C (main)
         \
          D'---E' (your-feature)

Note como o rebase cria novos commits (D’ e E’) enquanto o merge adiciona um commit de merge (M). O resultado do rebase é linear e limpo, enquanto o merge preserva o histórico exato mas adiciona complexidade.

Casos de Uso Comuns para Git Rebase

Atualizando Seu Branch de Feature

Você está trabalhando em uma funcionalidade enquanto sua equipe faz push de atualizações para o main. Para incorporar as mudanças deles:

git checkout your-feature-branch
git rebase main

Isso reproduz seus commits em cima do main mais recente, mantendo seu branch atualizado sem commits de merge.

Limpando Commits Antes de um Pull Request

Antes de compartilhar seu trabalho, você pode querer organizar seus commits. O rebase interativo permite:

git rebase -i HEAD~3

Isso abre um editor onde você pode:

• Comprimir múltiplos commits “work in progress” em um
• Reordenar commits para fluxo lógico
• Editar mensagens de commit para clareza

Por exemplo, transformar isso:

- Fix typo
- WIP: add login
- More login stuff
- Fix tests

Nisso:

- Add user login functionality with tests

Avisos Importantes: Quando NÃO Fazer Rebase

A Regra de Ouro: Não Faça Rebase de Branches Compartilhados

Nunca faça rebase de branches nos quais outros estão trabalhando. Quando você faz rebase, está criando novos commits com hashes SHA-1 diferentes. Se alguém mais tem os commits antigos, o Git fica confuso e cria commits duplicados.

Seguro para rebase: Seu branch de feature local
Nunca fazer rebase: main, develop, ou qualquer branch que outros usam

Entendendo os Riscos do Force Push

Após fazer rebase, você frequentemente precisará fazer force push:

git push --force-with-lease origin your-feature-branch

A flag --force-with-lease é mais segura que --force porque verifica se ninguém mais fez push de mudanças desde seu último pull. Ainda assim, só faça force push de branches que você possui.

Começando com Git Rebase

Aqui está um fluxo de trabalho simples para praticar:

1. Crie um branch de feature a partir do main
2. Faça alguns commits
3. Enquanto isso, o main é atualizado
4. Faça rebase do seu branch de feature:

   git checkout feature-branch
   git rebase main

5. Se conflitos ocorrerem, resolva-os e continue:

   git add .
   git rebase --continue

Comece com seus branches locais para ganhar confiança antes de fazer rebase de qualquer coisa compartilhada.

Conclusão

Git rebase é uma ferramenta poderosa para manter históricos de commit limpos e lineares. Ao reproduzir commits em vez de fazer merge, você cria um histórico de projeto mais legível que beneficia toda sua equipe. Lembre-se da regra de ouro—só faça rebase de branches que você não fez push ou que outros não estão usando—e você evitará as armadilhas comuns.

Comece a praticar com seus branches de feature hoje. Uma vez que você experimente a clareza de um histórico linear, você se perguntará como trabalhou sem ele.

Perguntas Frequentes

Understand every bug

Uncover frustrations, understand bugs and fix slowdowns like never before with OpenReplay — the open-source session replay tool for developers. Self-host it in minutes, and have complete control over your customer data. Check our GitHub repo and join the thousands of developers in our community.