Com o trabalho que acontece em um projeto de desenvolvimento, o Git é uma ferramenta fundamental. No entanto, quando você tem muitos colaboradores no projeto, ocasionalmente eles podem acabar se atrapalhando. Isso significa que dois desenvolvedores podem trabalhar na mesma parte de código e ambos podem fazer um commit. Nessas situações, é necessário recorrer a algumas estratégias de mesclagem (merge) no Git para resolver os conflitos.
Embora a mesclagem no Git possa ser direta em alguns casos, muitas vezes você precisa adotar abordagens avançadas. Isso inclui estratégias como mesclagem recursiva, mesclagem de três vias e muitas outras. Em certos momentos, pode ser necessário até mesmo desfazer uma mesclagem no Git.
Neste tutorial, vamos explorar algumas técnicas avançadas de mesclagem no Git para enriquecer as suas habilidades. Vamos ao que interessa!
Introdução às estratégias de mesclagem do Git
O conceito central de uma mesclagem é simples: você une duas branches para transformar vários commits em um só. No entanto, existem várias técnicas que você pode empregar para garantir que você faça o commit e a mesclagem do código correto.
Vamos analisar algumas estratégias importantes que você precisa entender. Elas não estão em nenhuma ordem e, em algum momento da sua carreira de desenvolvimento, você poderá precisar de todas elas. Além disso, você também precisará ter uma sólida compreensão dos conceitos básicos do Git, como ponteiros, branches e commits.
A diferença entre mesclagens de duas vias e três vias
É útil compreender a diferença entre uma mesclagem de duas vias e sua contraparte de três vias. A maioria das estratégias de mesclagem que abordaremos a seguir trata de situações de três vias. Na verdade, é mais simples explicar o que é uma mesclagem de três vias. Considere o exemplo a seguir:
- Você tem uma branch principal com vários commits e um branch de recursos que também tem commits.
- No entanto, se a branch principal fizer mais commits, ambas as branches divergirão.
- Em termos simples, tanto o branch principal quanto o branch de recursos têm commits que o outro não tem. Se você fizer a mesclagem deles usando uma abordagem bidirecional, perderá um commit (provavelmente no principal)
- Em vez disso, o Git criará um novo commit de mesclagem a partir da branch principal e de recurso atuais.
Em resumo, o Git examinará três pontos de controle diferentes para mesclar as alterações: o cabeçalho do principal, o cabeçalho do branch de recursos e o antecessor comum. Esse será o commit final comum ao branch principal e ao branch de recursos.
Na prática, não é necessário se preocupar se a estratégia de mesclagem é de duas ou três vias. Muitas vezes, a escolha da estratégia será irrelevante. Ainda assim, é bom entender como o Git funciona ao mesclar branches e repositórios.
Mesclagem de avanço rápido
A primeira estratégia pode não exigir que você tome nenhuma ação para executá-la. A mesclagem de avanço rápido move o ponteiro para o commit mais recente no branch principal (main) sem criar um commit adicional (o que pode ser confuso). É uma abordagem limpa que muitos desenvolvedores adotam como padrão.
A técnica começa com uma branch principal que pode ou não ter commits. Nesse caso, você abre uma nova branch, trabalha no código e faz commits. Nesse ponto, você também precisa mesclar essas alterações de volta ao principal. Uma mesclagem de avanço rápido tem um requisito para ser realizada:
- Você precisa garantir que nenhum outro commit ocorra no principal enquanto você trabalha na nova branch.
Isso nem sempre será possível, especialmente se você trabalha em uma equipe grande. Mesmo assim, se você optar por mesclar seus commits com um branch principal (main) que está atualizado e sem commits próprios, isso executará uma mesclagem de avanço rápido. Você pode fazer isso de algumas maneiras diferentes:
git merge <branch>
git merge --ff-only
Muitas vezes, você não precisará especificar que deseja executar uma mesclagem de avanço rápido. Esse tipo de mesclagem ocorre em projetos individuais ou com equipes pequenas. Em um ambiente de ritmo acelerado, essa é uma mesclagem rara. Por isso, outras serão mais comuns.
Mesclagem recursiva
Uma mesclagem recursiva muitas vezes é o padrão, pois ocorrerá com mais frequência em situações comuns do que outros tipos de mesclagem. Uma mesclagem recursiva é quando você faz commits em um branch, mas outros commits também ocorrem no branch principal (main).
Quando chega a hora de mesclar, o Git vai percorrer recursivamente o branch para criar seu commit definitivo. Isso significa que um commit de mesclagem terá dois pais quando você o completar.
Assim como em uma mesclagem de avanço rápido, você normalmente não precisa especificar uma mesclagem recursiva. No entanto, você pode garantir que o Git não escolha algo como uma mesclagem de avanço rápido usando os seguintes comandos e flags:
git merge --no-ff
git merge -s recursive <branch1> <branch2>
A segunda linha usa a opção de estratégia -s e a nomeação explícita para realizar uma mesclagem. Ao contrário de uma mesclagem de avanço rápido, uma mesclagem recursiva cria um commit de mesclagem dedicado. Para mesclagens de duas vias, uma estratégia recursiva é sólida e funciona bem.
Ours e Theirs
Uma situação comum durante o desenvolvimento é quando você cria uma nova funcionalidade em seu projeto que, no final das contas, não será aprovada. Em muitos casos, você terá muito código para mesclar que também é interdependente. Uma mesclagem ‘ours’ é a melhor maneira de resolver esses conflitos.
Esse tipo de mesclagem pode lidar com quantos branches forem necessários e trabalha para ignorar todas as alterações nesses outros branches. É ótimo se você deseja eliminar recursos antigos ou desenvolvimentos indesejados. Aqui está o comando que você precisa:
git merge -s ours <branch1> <branch2>Uma mesclagem ‘ours’ essencialmente significa que o branch atual contém o código de direito. Isso se relaciona com as mesclagens ‘theirs’, que tratam o outro branch como correto. No entanto, você precisa passar outra opção de estratégia aqui:
git merge -X theirs <branch2>
Usar as mesclagens “ours” e “theirs” pode ser confuso, mas, em geral, é seguro se ater aos casos de uso típicos (manter tudo no branch atual e descartar o restante).
Octopus
Lidar com múltiplos cabeçalhos – ou seja, mesclar mais de um branch em outro – pode ser uma situação complicada para um merge no Git. Pode-se dizer que você precisa de mais do que duas mãos para resolver os conflitos. É aqui que uma mesclagem do octopus (octopus merge) entra em cena.
As mesclagens de octopus são o oposto completo das mesclagens ‘ours’ e ‘theirs’. O caso de uso típico é quando você deseja incluir vários commits relacionados a recursos semelhantes e mesclá-los em um único commit. Aqui está como você especifica essa opção:
git merge -s octopus <branch1> <branch2>
No entanto, o Git recusará uma mesclagem do octopus (octopus merge) se você precisar fazer uma resolução manual posteriormente. Para resoluções automáticas, uma mesclagem do octopus será o padrão se você precisar mesclar vários branches em um só.
Resolve
Uma das maneiras mais seguras de mesclar commits, uma mesclagem de resolução (resolve merge) é ótima se você tiver uma situação que envolve mesclagens cruzadas. Também é um método rápido de resolução para implementar. Você pode querer usar esse método para históricos de mesclagem mais complexos, mas apenas aqueles com dois cabeçalhos.
git merge -s resolve <branch1> <branch2>
Como uma mesclagem de resolução usa um algoritmo de três vias para trabalhar com a branch atual e com a branch da qual você está tirando, ela pode não ser tão flexível quanto outros métodos de mesclagem. Entretanto, para o trabalho que você precisa fazer, a mesclagem de resolução é quase perfeita.
Subtree
Esse complemento de uma mesclagem recursiva pode confundir você. Tentaremos explicar isso usando um exemplo claro:
- Primeiro, considere duas árvores diferentes – X e Y. Geralmente, são dois repositórios.
- Você deseja mesclar as duas árvores em uma só.
- Se a árvore Y corresponder a uma das subárvores em X, a árvore Y será alterada para corresponder à estrutura X.
Isso significa que uma mesclagem de subárvore é fantástica se você quiser combinar vários repositórios em um artigo definitivo. Você também fará as alterações necessárias na árvore “antecessor” comum de ambas as branches.
git merge -s subtree <branch1> <branch2>
Em resumo, uma mesclagem de subtree é o que você deseja se precisar combinar dois repositórios. Na verdade, você pode ter dificuldade para entender qual estratégia de mesclagem é a ideal para você. Mais adiante, discutiremos algumas ferramentas que podem ajudar você.
Antes disso, existem alguns conflitos de mesclagem avançados que você precisa saber como resolver.
Como lidar com conflitos de mesclagem complexos do Git
Mesclar branches no Git é mais como gerenciar conflitos e resolvê-los. Quanto maior o tamanho da sua equipe e do seu projeto, maior a chance de conflitos. Alguns deles podem ser complexos e difíceis de resolver.
Considerando que os conflitos podem consumir tempo, dinheiro e recursos, você precisa descobrir como eliminá-los rapidamente. Geralmente, dois desenvolvedores trabalharão no mesmo conjunto de códigos e ambos decidirão fazer o commit.
Isso pode significar que você pode não conseguir iniciar a mesclagem devido a alterações pendentes ou ter uma falha durante uma mesclagem que exija intervenção manual. Quando o diretório de trabalho estiver “limpo”, você poderá começar. Muitas vezes, o Git o notificará sobre um conflito quando você iniciar uma mesclagem:
No entanto, para obter mais informações, você pode executar um git status e ver os detalhes:
A partir daqui, você pode começar a trabalhar nos vários arquivos que estão causando o conflito. Algumas das ferramentas e técnicas que discutiremos a seguir ajudarão você.
Abortando e reiniciando mesclagens
Às vezes, você precisa interromper a mesclagem completamente e começar com um ponto de partida relativamente limpo. De fato, ambos os comandos que mencionamos são adequados para situações em que você ainda não sabe o que fazer com um conflito.
Você pode optar por abortar ou reiniciar uma mesclagem em andamento com os seguintes comandos:
git merge --abort
git reset
Os dois comandos são semelhantes, mas você os usa em circunstâncias diferentes. Por exemplo, ao abortar uma mesclagem, você simplesmente reverterá o branch de volta ao estado anterior à mesclagem. Em alguns casos, isso não funcionará. Por exemplo, se o seu diretório de trabalho possuir alterações não confirmadas e não lançadas, você não poderá abortar.
No entanto, redefinir uma mesclagem significa que você reverte os arquivos de volta a um estado conhecido. Você deve considerar essa última opção se o Git não conseguir iniciar a mesclagem. Observe que esse comando excluirá todas as alterações que você não confirmar, o que significa que esse ato requer cuidado.
Verificação de conflitos
A maioria dos conflitos de mesclagem será simples de ser verificada e resolvida. Entretanto, em alguns casos, talvez você precise se aprofundar mais para descobrir por que um conflito ocorre e como começar a corrigi-lo.
Você pode obter mais contexto após um git merge usando um checkout:
git checkout --conflict=diff3 <filename>
Isso usa a navegação típica que um checkout fornece e cria uma comparação entre os dois arquivos que mostra o conflito de mesclagem:
Em um contexto técnico, isso verificará o arquivo novamente e substituirá os marcadores de conflito. Você pode fazer isso algumas vezes durante uma resolução. Aqui, se você passar o argumento diff3, ele fornecerá a versão base e as alternativas nas versões “ours” e “theirs”.
Observe que a opção de argumento padrão é merge, que não precisa ser especificado, a menos que você altere o estilo de conflito de mesclagem para diferente do padrão.
Ignorando o espaço negativo
O espaço negativo e seu uso é um ponto comum de discussão Algumas linguagens de programação usam tipos diferentes de espaçamento, e até mesmo desenvolvedores individuais usam formatação diferente.
A disputa entre espaços e tabulações é uma controvérsia da qual preferimos ficar de fora. No entanto, se você se deparar com situações em que a formatação varia entre espaços e tabulações dependendo do arquivo e das práticas de codificação, poderá enfrentar esse problema ao realizar uma mesclagem no Git.
Você identificará que isso é a causa da falha na mesclagem quando houver linhas removidas e adicionadas ao analisar o conflito:
Isso ocorre porque o Git analisa essas linhas e considera o espaço negativo como uma alteração.
No entanto, você pode adicionar argumentos específicos ao comando git merge que ignorarão o espaço negativo nos arquivos relevantes:
git merge -Xignore-all-space
git merge -Xignore-space-change
Embora esses dois argumentos pareçam semelhantes, eles têm uma diferença única. Se você optar por ignorar todo o espaço negativo, o Git o fará. É uma abordagem ampla, mas, em contraste, o -Xignore-space-change só contará as sequências de um ou mais caracteres com espaço negativo como equivalentes. Dessa forma, ele ignorará espaços simples no final das linhas.
Para maior segurança, você também pode revisar a mesclagem usando o comando --no-commit, a fim de verificar se você ignora e contabiliza o espaço negativo da maneira correta.
Mesclar registros
O registro é crucial para quase todo software que transmite dados. No Git, você pode usar o registro para obter mais detalhes sobre um conflito de mesclagem. Você pode acessar essas informações usando git log:
É basicamente um local onde todos os registros de ações em um repositório são armazenados em arquivos de texto. No entanto, você pode adicionar argumentos adicionais para personalizar a visualização e ver apenas os commits que deseja:
git log --oneline --left-right <branch1>...<branch2>
Você pode usar um “ponto triplo” para fornecer uma lista de commits envolvidos em duas branches durante uma mesclagem. Ele filtrará todos os commits que ambas as branches compartilham, o que deixará uma seleção de commits para você investigar mais.
Você também pode usar git log --oneline --left-right --merge para mostrar apenas os commits de ambos os lados de uma mesclagem que “tocam” um arquivo conflitante. A opção -p mostrará a você as alterações exatas de um “diff” específico, embora você deva observar que isso se aplica somente a commits que não sejam de mesclagem. Existe uma solução alternativa para isso, que abordaremos a seguir.
Usando o formato de diferença combinada para investigar um conflito de mesclagem no Git
Você pode usar a visualização que obtém com git log para investigar conflitos de mesclagem. Em circunstâncias típicas, o Git mesclará o código e preparará tudo o que for bem-sucedido. Isso fará com que você tenha apenas linhas conflitantes e poderá vê-las usando o comando git diff:
Esse formato de “combined diff” adiciona duas colunas extras de informações. A primeira informa se uma linha é diferente entre o seu branch (“ours”) e a cópia de trabalho; a segunda fornece a mesma informação para o branch “theirs”.
Para os sinais, um sinal de mais indica se uma linha é uma adição à cópia de trabalho, mas não naquele lado específico da mesclagem, e um sinal de menos indica se a linha foi removida.
Observe que você também pode ver esse formato de diff combinado no registro do Git usando alguns comandos:
git show
git log --cc -p
O primeiro é um comando que você usa em um commit de mesclagem para ver seu histórico. O segundo comando usa a funcionalidade do -p para mostrar as alterações em um commit sem mescla com o formato de diff combinado.
Como desfazer uma mesclagem do Git
Erros podem acontecer, e você pode realizar mesclagens que precisam ser revertidas. Em alguns casos, você pode simplesmente alterar o commit mais recente usando git commit --amend. Isso abrirá o editor para permitir que você modifique a mensagem do último commit.
Embora você possa reverter conflitos de mesclagem mais complexos e as alterações resultantes, isso pode ser difícil porque os commits geralmente são permanentes.
Dessa forma, existem muitas etapas que você precisa seguir:
- Primeiro, você precisa revisar os commits e encontrar indicações às mesclagens de que precisa.
- Em seguida, você deve verificar as branches para analisar os históricos dos commits.
- Após conhecer as branches e os commits de que você precisa, há comandos específicos do Git com base na ação desejada.
Vamos examiná-los com mais detalhes e começar com o processo de revisão. A partir daí, podemos mostrar uma maneira rápida de desfazer uma mesclagem no Git e, em seguida, examinar comandos específicos para casos de uso mais avançados.
Revisão de commits
O comando git log --oneline é ótimo se você quiser ver os IDs de revisão e a mensagem do commit relacionados ao branch atual:
O comando git log --branches=* mostrará as mesmas informações, mas para todas as branches. Independentemente disso, você pode usar os IDs de indicação juntamente com um git checkout para criar um estado ‘detached HEAD‘. Isso significa que, do ponto de vista técnico, você não trabalhará em nenhuma branch e, quando voltar para uma branch estabelecida, as alterações ficarão “órfãs”.
Dessa forma, você pode usar o checkout como uma área de teste sem riscos. No entanto, caso queira preservar as alterações, você pode fazer o checkout da branch e dar a ela um novo nome usando git checkout -b <branch-name>. Essa é uma maneira sólida de desfazer uma mesclagem do Git, mas existem maneiras mais detalhadas de fazer isso para casos de uso avançados.
Usando o git reset
Muitos dos seus conflitos de mesclagem podem ocorrer em um repositório local. Nesses casos, git reset é o comando de que você precisa. No entanto, esse comando tem mais parâmetros e argumentos que você precisa conhecer. Veja a seguir como você usa o comando na prática:
git reset --hard <reference>
A primeira parte – git reset --hard – passa por três etapas:
- Ele move o branch de referência para sua localização antes do commit de mesclagem.
- O hard reset faz com que o “índice” (ou seja, o próximo ponto de controle de commit proposto) se pareça com o branch de indicação.
- Faz com que o diretório de trabalho se pareça com o índice.
Quando você realiza esse comando, o histórico de commits remove os commits posteriores e redefine o histórico para o ID referenciado. É uma maneira limpa de desfazer uma mesclagem do Git, mas não é adequada para todos os casos.
Por exemplo, você causará um erro se tentar enviar um commit de redefinição local para um repositório remoto que contenha esse commit. Nesse cenário, há outro comando que você pode usar.
Usando o git revert
Embora git reset e git revert pareçam semelhantes, existem algumas diferenças importantes. Nos exemplos até agora, o processo de desfazer envolve mover os ponteiros de referência e o HEAD para um commit específico. É como se você estivesse embaralhando cartas de baralho para criar uma nova ordem.
Por outro lado, o git revert cria um novo commit com base nas alterações de backtracking, atualiza os ponteiros de referência e torna o branch a nova “ponta” É também por isso que você deve usar esse comando para conflitos de mesclagem de repositório remoto.
Você pode usar o git revert <reference> para desfazer uma mesclagem do Git. Observe que você sempre precisa especificar uma indicação de commit, ou o comando não será executado. Você também pode passar HEAD para o comando para reverter para o commit mais recente.
No entanto, você pode dar ao Git mais clareza sobre o que deseja fazer:
git revert -m 1 <reference>
Quando você executar a mesclagem, o novo commit terá duas “origens” Uma está relacionada à indicação que você especificou e a outra é a ponta do branch que você deseja mesclar. Nesse caso, -m 1 diz ao Git para manter a primeira origem – ou seja, a indicação especificada – como a “linha principal”
A opção padrão para git revert é -e ou --edit. Isso abrirá o editor para que você possa alterar a mensagem de confirmação antes de reverter. No entanto, você também pode passar --no-edit, que não abrirá o editor.
Você também pode passar -n ou --no-commit. Isso diz a git revert para não criar um novo commit, mas “inverter” as alterações e adicioná-las ao índice de teste e ao diretório de trabalho.
A diferença entre merge e rebase no Git
Em vez de usar o comando git merge, você também pode usar git rebase. Essa também é uma maneira de integrar as alterações em um diretório, mas com uma diferença:
- Uma mesclagem de três vias é o padrão quando você usa
git merge. Ele combina pontos de controle de dois branches atuais e os mescla com um antecessor comum de ambos para criar um novo commit. - O rebasing envolve pegar uma alteração corrigida de uma branch divergente e aplicá-la a outra, sem a necessidade do antecessor. Isso significa que não haverá um novo commit.
Para usar esse comando, faça checkout em uma branch para a qual você gostaria de fazer rebase. A partir daí, você pode usar o seguinte comando:
git rebase -i <reference>
Em muitas situações, sua indicação será o branch principal. A opção -i inicia o “rebase interativo” Isso dá a você a oportunidade de alterar os commits à medida que eles se movem. Você pode usar isso para limpar o histórico de commits, que é uma das grandes vantagens de usar git rebase.
Ao executar o comando, você verá uma lista de possíveis commits a serem movidos no editor. Isso dá a você um escopo completo para alterar a aparência do histórico de commits. Você também pode mesclar commits se alterar o comando pick para fixup. Quando você salvar as alterações, o Git executará o rebase.
De modo geral, você usa o Git Merge para muitos conflitos. No entanto, o rebase também tem muitos benefícios. Por exemplo, embora o merge seja simples de usar e permita que você preserve o contexto em torno do seu histórico de merge, o rebase pode ser mais limpo, pois você pode simplificar o histórico de commits em um só.
Apesar disso, você precisa tomar mais cuidado com o rebase, pois o potencial de erros é enorme. Além disso, você não deve usar essa técnica em branches públicas, pois o rebase afetará apenas o seu repositório. Para corrigir os problemas resultantes, você precisará fazer ainda mais mesclagens e verá vários commits.
Ferramentas que ajudam você a gerenciar melhor uma mesclagem no Git
Dadas as complexidades que envolvem os conflitos de mesclagem no Git, talvez você queira uma ajuda. Existem muitas ferramentas disponíveis para ajudá-lo a realizar uma mesclagem bem-sucedida e, se você usa o Intellij IDEA, tem um método integrado usando o menu Branches:
Os usuários mais antigos do Atom descobrirão que a Microsoft manteve sua fantástica integração com o Git, com a capacidade de se conectar ao GitHub sem outras extensões ou complementos.
Você também tem mais opções usando a Command Palette. Isso acontece até mesmo em editores que se baseiam no framework de código aberto do VSCode, como o Onivim2:
A vantagem aqui, como é o caso de todas as ferramentas desta lista, é que você não precisa da linha de comando para realizar mesclagens. Normalmente, você precisa selecionar um branch de origem e um branch de destino em um menu suspenso e, em seguida, deixar que o editor realize a mesclagem. Mesmo assim, você não precisa adotar uma abordagem sem intervenção. Você pode revisar as alterações depois e, em seguida, fazer o commit de que precisa.
Um editor que oferece uma interface gráfica de usuário (GUI) separada para trabalhar com o Git é o Sublime Text. Se você usa esse editor, o Sublime Merge pode ser um complemento ideal para o seu fluxo de trabalho:
Independentemente da escolha do editor de código que você fizer, ele geralmente incluirá a capacidade de trabalhar com o Git sem usar a linha de comando. Isso acontece até mesmo com o Vim e o Neovim, usando o plugin Git Fugitive de Tim Pope, que é fantástico e simples de usar.
No entanto, existem algumas ferramentas de mesclagem de terceiros dedicadas que se concentram exclusivamente nessa tarefa.
Aplicativos dedicados de mesclagem do Git
Por exemplo, o Mergify é uma forma de nível empresarial de mesclar código que se integra ao fluxo de trabalho e ao pipeline de integração contínua/entrega contínua (CI/CD):
Alguns dos recursos aqui ajudam você a automatizar a atualização de suas solicitações pull antes da mesclagem, reordená-las com base na prioridade e também colocá-las em lote. Para uma solução de código aberto, o Meld pode ser útil:
Sua versão estável é compatível com Windows e Linux e é executada sob a licença GPL. Isso oferece a você a funcionalidade básica para comparar branches, editar suas mesclagens e muito mais. Você ainda obtém comparações de duas ou três vias e suporte para outros sistemas de controle de versão, como o Subversion.
Resumo
O Git é uma ferramenta essencial para você colaborar e gerenciar as alterações de código com eficiência. No entanto, se vários desenvolvedores trabalharem no mesmo código, podem surgir conflitos. As estratégias de mesclagem do Git ajudarão você a resolver esses conflitos, e existem muitas maneiras de fazer o trabalho. Para estratégias de mesclagem do Git mais complexas, você precisa recorrer a táticas avançadas.
Isso pode até ser tão simples quanto ignorar o espaço negativo ou vasculhar os registros de pesquisa. No entanto, você também não precisa usar sempre a linha de comando. Há muitos aplicativos para ajudar você e o seu editor de código também costuma usar uma interface integrada.
Se você quiser garantir a hospedagem de aplicativos de alta qualidade, temos o que você precisa. Nossos serviços de hospedagem de aplicativos baseados na nuvem garantem que seu aplicativo Full-Stack esteja pronto em pouco tempo.
Qual dessas estratégias de mesclagem do Git tirará você de uma situação difícil? Diga-nos na seção de comentários abaixo!
Deixe um comentário