Git e Github: Como Mesclar Branches e Resolver Conflitos

Esta publicação faz parte de uma série que aborda as ferramentas Git e Github de uma forma aprofundada, porém voltada para iniciantes.

Se você está iniciando seus estudos ou possui menos de 1 ano de experiência nessas ferramentas ou em ferramentas similares como Bitbucket, Gitlab, Git no Google Cloud, Git AWS com CodeCommit e outras, esta série será ótima para você. Aproveite!

Para acessar as outras publicações da série, acesse:

Introdução

Este é a quarta e última publicação da Série: Git e Github para iniciantes e você vai aprender aqui sobre mesclagem de branches e como resolver conflitos.

Para se beneficiar por completo desta postagem, você precisa ter o Git instalado em seu computador. Utilize os links abaixo se precisar de ajuda com isso.

Como instalar o Git no computador. E retorne aqui para continuarmos.

Índice desta publicação

Mesclando branches

Também chamamos as mesclagens de merges. Esta é a forma como o GIT une duas ou mais pontas bifurcadas anteriormente com a criação de branches e integra em uma única ramificação.

O branch corrente é o que recebe a mesclagem e os demais branches não sofrem nenhuma alteração. Imagine que temos dois branches em nosso repositório: main e func1.

Para atualizarmos o main devemos nos certificar que estamos dentro dele com o comando git checkout main e então executar git merge func1. Desta forma func1 será mesclado com o main e func1 pode ser excluído de forma segura.

Estratégia de merge

O GIT vai resolver internamente qual tipo de estratégia ele vai utilizar para realizar merge, mas em geral o que ocorre na mesclagem de dois branches é uma busca por uma base comum entre esses branches e a partir desse ponto ele faz a mesclagem do histórico antes separado.

Em alguns casos o GIT pode encontrar partes do mesmo arquivo alterado em ambos os históricos e ele pode não ser capaz de realizar a mesclagem. Neste cenário ocorrem os conflitos, onde será necessária a ação do usuário para correção.

Vamos continuar com nosso projeto e fazer algumas mesclagens. Abra seu programa de linha de comando e crie dois branches: func1 e func2.

C:\Users\Master\meu-site(main -> origin)
λ git branch func1

C:\Users\Master\meu-site(main -> origin)
λ git branch func2

Alterne para func1, faça alterações nos arquivos e faça um commit. Repita esse processo para o branch func2 também.

Posteriormente, alterne para o branch main novamente, crie um novo arquivo e faça um commit dessa nova alteração dentro do main. Abaixo a sequência de comandos:

λ git checkout -b func1
λ echo "esse é o func1" > func1.txt
λ git add .
λ git commit -am "func1 alterado"

λ git checkout main

λ git checkout -b func2
λ echo "esse é o func2" > func2.txt
λ git add .
λ git commit -am "func2 alterado"

λ git checkout main
λ echo "update main" > updatemain.txt

λ git add .
λ git commit -am "novo arquivo main"

Nesse momento, nossa árvore do repositório estará mais ou menos assim:

Vamos executar a mesclagem dos branches criados para dentro do branch principal main com os seguintes comando abaixo, observe bem como ficará nossa árvore de commits logo após estas ações.

C:\Users\Master\meu-site(main -> origin)
λ git checkout main
λ git merge func1
Merge made by the 'ort' strategy.
 func1.txt | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 func1.txt

C:\Users\Master\meu-site(main -> origin)
λ git merge func2
Merge made by the 'ort' strategy.
 func2.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

Resolvendo conflitos com GIT

Imagine o cenário em que dois devs (João e Maria) estão trabalhando em diferentes recursos em um projeto usando o Git. Eles começaram a trabalhar na mesma área do código e fizeram alterações em um arquivo chamado “app.js”.

Quando João tentou mesclar seu trabalho com o ramo principal do projeto (chamado “master”), ele recebeu uma mensagem de erro dizendo que havia conflitos na mesclagem. Isso ocorre porque Maria também fez alterações no mesmo arquivo “app.js”.

Para João resolver este problema ele vai precisar atualizar o seu repositório local para incluir as alterações que Maria fez, executando git pull origin buscando as atualizações mais recentes do repositório remoto.

Em seguida, João precisa abrir o arquivo “app.js” e procurar as áreas em conflito que estarão marcadas por marcas de conflito do Git, como “<<<<<<< HEAD” e “>>>>>>>”. Essas marcas indicam onde as alterações de João e de Maria se sobrepõem.

João precisa revisar as alterações e decidir qual versão do código manter. Ele pode decidir manter as alterações dele, as alterações de Maria ou mesclar as alterações das duas partes.

Quando João terminar de revisar as alterações e decidir como resolvê-las, ele precisa salvar o arquivo “app.js”.

Em seguida, precisa adicionar o arquivo ao índice do Git usando o comando git add, realizar o commit, enviar suas alterações via push para o repositório remoto e dormir em paz novamente ;).

Conclusão

Esta série foi bastante extensa e detalhada sobre como trabalhar com GIT e Github. Espero que estas publicações estejam acrescentando valor ao seu dia a dia como profissional.

Nos vemos na próxima publicação!

Tags