Como corrigir conflito de mesclagem do Git: guia passo a passo completo 2026

A conflito de mesclagem acontece quando o Git não consegue combinar alterações automaticamente porque duas ramificações modificaram as mesmas linhas de maneira diferente. É uma parte normal da colaboração — não é um erro, apenas o Git pedindo para você decidir. Veja como resolver conflitos com confiança.

O que causa um conflito de mesclagem

Quando você mescla (ou rebase, ou extrai) e ambas as ramificações alteram a mesma parte de um arquivo de maneira diferente, o Git não consegue decidir qual alteração manter – então ele para e pergunta a você. Você verá:

$ git merge feature-branch
Auto-merging app.js
CONFLICT (content): Merge conflict in app.js
Automatic merge failed; fix conflicts and then commit the result.

Compreendendo os marcadores de conflito

<<<<<<< HEAD
const greeting = "Hello from main branch";
=======
const greeting = "Hi from feature branch";
>>>>>>> feature-branch

// The markers mean:
// <<<<<<< HEAD          → your current branch's version (above =======)
// =======              → divider
// >>>>>>> feature-branch → the incoming branch's version (below =======)

Resolução passo a passo

# 1. See which files have conflicts
git status
# Unmerged paths:
#   both modified:   app.js

# 2. Open each conflicted file and find the conflict markers

# 3. Edit the file to the desired final state - choose one version,
#    combine both, or write something new. REMOVE the markers.

# Before (with markers):
<<<<<<< HEAD
const greeting = "Hello from main branch";
=======
const greeting = "Hi from feature branch";
>>>>>>> feature-branch

# After (resolved - you decided):
const greeting = "Hi from feature branch";

# 4. Stage the resolved file
git add app.js

# 5. Complete the merge
git commit           # opens editor with a default merge message, or:
git commit -m "Merge feature-branch, resolve greeting conflict"

Resolvendo Vários Conflitos

# A file (or several) may have multiple conflict sections.
# Find them all:
grep -n "<<<<<<<" app.js       # find conflict markers

# Resolve each section, then verify none remain:
grep -rn "<<<<<<<\|=======\|>>>>>>>" .
# Should return nothing when all conflicts are resolved

# Then stage all resolved files and commit
git add .
git commit

Usando uma ferramenta de mesclagem

# Configure and use a visual merge tool (easier for complex conflicts)
git config --global merge.tool vscode
git config --global mergetool.vscode.cmd 'code --wait $MERGED'

# Launch the tool for conflicts
git mergetool
# VS Code (or your tool) shows current/incoming/result panes for easy resolution

# VS Code also has built-in conflict resolution - it shows
# "Accept Current / Accept Incoming / Accept Both" buttons inline

Abortando uma mesclagem

# If you want to cancel the merge and start over
git merge --abort
# Returns your branch to the state before the merge - nothing changed

# For a conflicted rebase:
git rebase --abort

# For a conflicted pull:
git merge --abort   # (a pull is a fetch + merge)

Resolvendo Conflitos Durante Rebase

# Rebase conflicts are resolved similarly, but per-commit:
git rebase main
# CONFLICT in app.js

# 1. Resolve the conflict in the file
# 2. Stage it
git add app.js
# 3. Continue the rebase (NOT commit)
git rebase --continue
# Repeat if more commits have conflicts

Prevenindo Conflitos

• Puxe com frequência: Manter-se atualizado com o ramo principal reduz divergências e conflitos
• Faça commits menores e focados: Mais fácil de mesclar do que grandes mudanças radicais
• Comunique-se com sua equipe: Coordene quem está trabalhando no quê para evitar mudanças sobrepostas
• Mesclar/rebase frequentemente: Integre as mudanças regularmente em vez de deixar as filiais divergirem por semanas
• Mantenha os galhos de curta duração: Filiais de longa duração acumulam conflitos

Perguntas Frequentes

P: O que significam os marcadores de conflito?
A: <<<<<<< HEAD inicia a versão atual do seu branch,======= divide-o da versão recebida e>>>>>>> branch-name encerra a versão recebida. Edite o arquivo para o estado final desejado e remova todos os três marcadores, depois prepare e confirme.

P: Como escolho qual versão manter?
R: Entenda o que cada mudança faz e então decida: manter a sua, manter a deles, combinar as duas ou escrever algo novo. Não existe uma resposta “certa” automática – depende do que o código deve fazer. Quando não tiver certeza, pergunte à pessoa que fez a outra alteração. Edite para o estado final correto.

P: Cometi um erro ao resolver. Como faço para recomeçar?
R: Se você ainda não se comprometeu, executegit merge --abort (ougit rebase --abort) para cancelar e retornar ao estado de pré-mesclagem. Em seguida, inicie a mesclagem novamente. Se você já cometeu uma resolução incorreta, poderá reverter ou redefinir a confirmação de mesclagem.

P: Como posso saber se todos os conflitos foram resolvidos?
R: Corregit status (não há caminhos não mesclados restantes) e procure por marcadores restantes:grep -rn "<<<<<<<" . não deve retornar nada. Marcadores de conflito restantes em arquivos causam bugs, portanto, sempre verifique se não resta nenhum antes de confirmar.

P: Por que continuo tendo o mesmo conflito durante o rebase?
R: O Rebase aplica seus commits um de cada vez, portanto, um conflito pode ocorrer entre vários commits que tocam o mesmo código. Resolva cada um,git addegit rebase --continue. Se for genuinamente repetitivo, consideregit rerere (reutilizar a resolução gravada) ou mesclar em vez de rebase.

Conclusão

Conflitos de mesclagem são uma parte normal da colaboração, não erros — o Git está pedindo que você decida quando duas ramificações alteraram o mesmo código de maneira diferente. O processo de resolução:encontre arquivos em conflito comgit status, abra-os e localize os marcadores de conflito (<<<<<<< HEAD / ======= / >>>>>>>), edite para o estado final desejado removendo os marcadores e, em seguida,git add egit commit. Use uma ferramenta de mesclagem visual (VS Code) para conflitos complexos egit merge --abort para recomeçar, se necessário. Durante o rebase, resolva por commit e usegit rebase --continue. Evite conflitos puxando com frequência, fazendo pequenos commits e mantendo as ramificações de curta duração. Depois de entender os marcadores e o processo, os conflitos se tornam rotineiros — basta o Git pedir uma decisão que você está preparado para tomar.