Git Merge ou Git Rebase? Entenda a Diferença e Quando Usar Cada Um

Merge e rebase integram branches no Git de formas diferentes. Veja como cada um funciona, prós, contras e quando usar em seus projetos.

Compartilhar no Linkedin Compartilhar no WhatsApp

Tempo estimado de leitura: 8 minutos

Imagem do artigo Git Merge ou Git Rebase? Entenda a Diferença e Quando Usar Cada Um

Quem trabalha com Git em equipe cedo ou tarde precisa juntar o trabalho feito em uma branch com outra. Para isso existem dois caminhos principais: git merge e git rebase. Os dois resolvem o mesmo problema, que é integrar alterações, mas fazem isso de maneiras bem diferentes e deixam o histórico do projeto com aparências distintas. Neste artigo você vai entender o que cada comando faz por baixo dos panos, ver exemplos práticos e aprender a escolher o mais adequado para cada situação.

O cenário de partida

Imagine que a branch main tem os commits A e B. Você cria uma branch chamada feature a partir de B e faz dois commits, C e D. Enquanto isso, um colega adiciona o commit E na main. Agora as duas branches divergiram: ambas partem de B, mas cada uma seguiu um caminho.

          C---D   feature
         /
    A---B---E     main

A pergunta é: como levar C e D para junto de E? É aqui que merge e rebase tomam rumos diferentes.

Como funciona o git merge

O merge junta as duas linhas de desenvolvimento criando um novo commit especial, chamado commit de merge, que tem dois “pais”: o último commit de cada branch. Estando na main, você executa:

git checkout main
git merge feature

O resultado é um histórico que preserva exatamente o que aconteceu:

          C---D
         /     \
    A---B---E---M   main

O commit M registra o momento da integração. Nenhum commit existente é alterado. Se a main não tivesse recebido commits novos, o Git faria um fast-forward: apenas moveria o ponteiro da main para D, sem criar commit de merge (a menos que você use a opção --no-ff).

Como funciona o git rebase

O rebase segue outra lógica: ele “reaplica” seus commits em cima de uma nova base. Estando na feature, você executa:

git checkout feature
git rebase main

O Git separa temporariamente C e D, posiciona a feature sobre E e aplica as mesmas mudanças novamente, gerando commits novos, C’ e D’:

    A---B---E---C'---D'   feature
            |
           main

C’ e D’ têm o mesmo conteúdo de C e D, mas são commits diferentes, com novos identificadores (hashes). Depois disso, integrar na main vira um simples fast-forward, e o histórico fica linear, como se você tivesse começado a trabalhar depois de E.

Comparação direta

Aspectogit mergegit rebase
HistóricoPreserva a ordem real, com ramificaçõesFica linear e mais limpo
Commits existentesNão são alteradosSão reescritos com novos hashes
Commit extraCria commit de merge (exceto fast-forward)Não cria
ConflitosResolvidos uma vez, no commit de mergePodem surgir commit a commit
Segurança em branches compartilhadasSeguroArriscado se os commits já foram enviados

A regra de ouro do rebase

Como o rebase reescreve commits, existe uma regra amplamente adotada: não faça rebase de commits que já foram publicados e que outras pessoas usam. Se um colega baseou o trabalho dele nos seus commits C e D e você os substitui por C’ e D’, o histórico dele deixa de bater com o remoto. O resultado costuma ser confusão, commits duplicados e conflitos difíceis de entender.

Depois de um rebase em uma branch que já estava no servidor, o git push comum é recusado, e é preciso forçar o envio. Se for realmente necessário, prefira git push --force-with-lease, que só sobrescreve o remoto se ninguém tiver enviado algo novo desde a sua última atualização.

Resolvendo conflitos em cada caso

Nos dois comandos podem surgir conflitos quando a mesma parte de um arquivo foi alterada nas duas branches. O processo muda um pouco:

  • No merge: você edita os arquivos em conflito, faz git add e conclui com git commit. Para desistir, use git merge --abort.
  • No rebase: o Git para no commit problemático. Você corrige, faz git add e segue com git rebase --continue. Para pular aquele commit, git rebase --skip; para cancelar tudo e voltar ao estado anterior, git rebase --abort.

Rebase interativo: organizando seus commits

Uma variação muito útil é o rebase interativo, com git rebase -i. Ele abre uma lista dos commits recentes e permite reordenar, juntar (squash), editar mensagens ou descartar commits antes de compartilhar o trabalho. É ótimo para transformar uma sequência como “teste”, “corrige erro”, “agora vai” em um único commit com mensagem clara. Mais uma vez, o ideal é usar isso apenas em commits locais, ainda não publicados.

Quando usar cada um

  • Use merge para integrar uma branch de funcionalidade concluída na branch principal, especialmente em branches compartilhadas, e quando o time valoriza registrar exatamente quando cada integração aconteceu.
  • Use rebase para atualizar sua branch local com as novidades da principal antes de abrir um pull request, e para limpar commits pessoais antes de enviá-los.
  • Combine os dois: muitas equipes fazem rebase da branch de trabalho sobre a main para manter tudo atualizado e depois integram via merge ou via “squash and merge” na plataforma de código.

Não existe resposta única. O mais importante é que a equipe combine uma convenção e a siga com consistência, de preferência documentada no guia de contribuição do projeto.

Comandos úteis para enxergar o que aconteceu

Antes e depois de um merge ou rebase, vale visualizar o histórico para ter certeza de que tudo saiu como esperado. Alguns comandos ajudam bastante nessa tarefa:

  • git log --oneline --graph --all: mostra todas as branches em forma de árvore, deixando claro onde há ramificações e commits de merge.
  • git status: indica se há um merge ou rebase em andamento e quais arquivos estão em conflito.
  • git reflog: lista os movimentos recentes dos ponteiros do repositório. Se um rebase der errado, é com ele que você encontra o estado anterior e consegue voltar, por exemplo com git reset --hard apontando para a entrada desejada.

Saber que o reflog existe tira boa parte do medo de experimentar: mesmo commits que parecem ter sumido depois de um rebase costumam continuar acessíveis por algum tempo no repositório local.

Conclusão

Merge preserva a história como ela aconteceu; rebase reescreve a história para deixá-la linear e fácil de ler. Ambos são ferramentas legítimas, e saber quando usar cada uma evita conflitos desnecessários e deixa o histórico do projeto muito mais compreensível. Se você quer dominar Git, GitHub e outras ferramentas do dia a dia de quem trabalha com tecnologia, confira os cursos gratuitos de Ferramentas de TI na Cursa e pratique em projetos reais.

Cookies, Cache e Histórico: O Que o Navegador Guarda Sobre Você

Entenda o que são cookies, cache e histórico do navegador, para que servem, quando limpar cada um e como isso afeta sua privacidade.

Sensores e Atuadores: Como o Arduino Percebe o Mundo e Age Sobre Ele

Entenda a diferença entre sensores e atuadores, como o Arduino lê sinais e aciona dispositivos, e como montar seus primeiros projetos.

Endereço IP, Máscara de Sub-rede e Gateway: O Trio Que Faz Sua Rede Funcionar

Entenda de forma prática o que são endereço IP, máscara de sub-rede e gateway padrão, e como esses três parâmetros conversam entre si.

Compressão de Arquivos: Como o ZIP Consegue Reduzir o Tamanho dos Seus Dados

Entenda como funciona a compressão de arquivos, a diferença entre métodos com e sem perda e quando cada formato faz sentido.

Expressões Regulares (Regex): O Que São e Como Usar na Prática

Aprenda o que são expressões regulares, os principais símbolos, quantificadores e como aplicar regex para buscar e validar textos.

Como Funciona o DNS: o Sistema que Traduz Nomes em Endereços na Internet

Entenda de forma simples o que é DNS, como acontece a resolução de nomes, os principais tipos de registro e por que ele é essencial para a internet.

INNER JOIN, LEFT JOIN e RIGHT JOIN: como relacionar tabelas no SQL

Entenda de forma simples como funcionam INNER JOIN, LEFT JOIN, RIGHT JOIN e FULL JOIN para combinar dados de várias tabelas no SQL.

TypeScript para iniciantes: o que é e por que ele melhora o JavaScript

Entenda o que é TypeScript, como a tipagem estática ajuda a evitar erros e por que ele se tornou essencial no desenvolvimento web moderno.