Se você estiver usando o Git para gerenciamento de código-fonte, talvez precise mesclar diferentes branches de desenvolvimento para um projeto em um único branch. Este artigo irá guiá-lo sobre como combinar duas branches de desenvolvimento com o comando de mesclagem do Git.
Nós vamos mostrar como criar um projeto Git, criar diferentes branches e mesclar um branch em outro. Além disso, você aprenderá o que é uma mesclagem rápida e uma mesclagem de 3 vias, e como mesclar um branch em um repositório remoto.
O que é mesclagem no Git?
O Git é uma ferramenta DevOps popular que os desenvolvedores podem usar para rastrear e gerenciar alterações no código escrito por diferentes equipes. Com o comando Git merge, você pode pegar seu branch de desenvolvimento atual (que você bifurcou do branch principal) e mesclar as mudanças de código de volta no branch principal.
A mesclagem no Git é um comando que você usará com mais frequência quando estiver trabalhando em uma equipe. Pode haver momentos em que você e outro desenvolvedor possam colaborar em uma característica em dois branches separados. No entanto, quando chegar a hora, você precisará combinar seu trabalho em um branch, testar aquelas mudanças e então mesclar seu desenvolvimento colaborativo no branch de desenvolvimento principal.
À medida que o ramo principal de desenvolvimento está sendo atualizado, o ramco de recurso separado em que você e outros desenvolvedores estão trabalhando não será atualizado com as mudanças da sua equipe. Portanto, como uma prática recomendada, quando chegar a hora de criar uma solicitação de pull, você sempre deve começar atualizando sua versão local do ramo principal com as últimas alterações. Em seguida, você pode mesclar o ramo principal atualizado em seu ramo de desenvolvimento antes de confirmar e fazer a solicitação de pull para mesclá-lo no ramo principal de desenvolvimento.
Como combinar dois ramos Git com o Git merge
Como desenvolvedor, ser proficiente em Git pode realmente ajudar a torná-lo mais produtivo. Para começar, é fundamental entender como executar comandos do Git a partir da linha de comando. Antes de começarmos, vamos ver o que você terá que configurar primeiro antes de começar a mesclar diferentes ramos do Git.
Pré-requisitos
Para começar, você precisará dos seguintes itens:
- A Windows, Mac, or Linux machine to run Git.
- O aplicativo Git, que está disponível para download aqui.
- A GitHub or Gitlab account.
- Software de edição de código como o Visual Studio Code.
Vamos rapidamente revisar os diferentes passos necessários para instalar o Git em um PC com Windows (também temos um guia separado sobre como instalar o Git no Ubuntu):
- Siga o link para baixar o Git para o seu computador e instale os arquivos.
- Depois de instalado, abra o terminal e digite git –version:
git –version
Se você receber um número de versão de retorno, ótimo! No entanto, se receber uma mensagem de “comando não encontrado”, então talvez precise adicionar o Git à sua variável $PATH. Isso geralmente é um problema do Windows.
Vamos remediar isso rapidamente para que você não precise se perder em busca.
- Vá até a barra de Início e clique com o botão direito em Este Computador.
- Selecione Propriedades.
- Clique em Configurações Avançadas do Sistema.
- Em Propriedades do Sistema, clique em Variáveis de Ambiente. Aqui, você pode adicionar valores à variável $PATH.
- Selecione $PATH e clique em Editar.
- Clique em Novo e adicione um caminho para o git/cmd.
- Clique em Novo e adicione o caminho para o arquivo git.exe.
Salve as alterações, volte ao terminal e execute novamente o comando git -version.
git -version
Agora você deve receber o número da versão. Após fazer o pré-trabalho e configurar sua conta do GitHub ou Gitlab, você deve estar pronto para começar.
Criando um projeto Git
Nesta seção, vou guiá-lo(a) pelos diferentes passos necessários para criar um novo repositório.
Em sua conta recém-criada no Github, clique em Novo no lado esquerdo da tela.
Em seguida, você precisará dar um nome ao seu repositório e preencher alguns outros detalhes. Dê uma descrição breve, se desejar, torne-o público e uma boa prática é sempre adicionar um arquivo ReadMe. Quando terminar, clique em Criar repositório.
Agora, para começar a trabalhar em seu editor de código, você vai querer clonar seu novo repositório clicando no botão Clonar. Selecione HTTPS, copie o endereço e abra seu terminal.
No terminal, use o comando cd para escolher onde deseja criar um novo diretório para seu projeto.
cd user/desktop/repo/
Quando estiver no branch correto, use o comando mkdir para criar um novo diretório:
mkdir <name of your directory>
Agora, vamos usar o comando cd novamente para mudar para esse diretório recém-criado:
cd <name of your newly created directory>
Uma vez no novo diretório, use o comando git init para criar um novo repositório:
git init
Em seguida, use o comando git clone com o endereço HTTPS correto e pressione Enter. Por padrão, isso criará um branch principal no seu repositório local.
git clone <paste https address here>
Agora, abra o repositório clonado recentemente com o Visual Studio Code. Agora você pode começar a escrever código.
Depois de criar seu repositório, você já estará no branch principal. Como uma melhor prática, você nunca deve, em hipótese alguma, enviar código diretamente para o branch principal, que precisa estar protegido.
Para fins deste tutorial, não vamos abordar ramos Git protegidos. Mas no campo, você nunca conseguirá enviar código para o ramo principal sem uma solicitação de recebimento.
Criando outro ramo Git
Estamos atualmente no ramo principal, você codificou algo para criar algum conteúdo e agora deseja criar um novo ramo.
Em seu terminal, use o comando git checkout para criar um novo ramo e alternar automaticamente para ele:
git checkout -b <name of new branch>
O comando deve cortar automaticamente esse novo ramo do seu ramo principal, para que o código deste não seja alterado.
Agora, aqui vem a parte divertida onde poderemos usar o comando git merge. Em seu novo ramo criado, antes de mais nada, você precisará adicionar mais código para que seu ramo esteja à frente do ramo principal com algumas novas alterações.
Agora que você deseja mesclar este novo ramo no principal, pode encontrar um conflito de mesclagem, que é uma inserção de código que entra em conflito com o código que já existe. Realmente não é divertido lidar com esses problemas.
Então, o que você faz? Vamos ver como mesclar um ramo no outro.
Mesclando seus dois ramos Git no seu repositório local
Enquanto estiver no seu novo ramo, vá para o terminal e use o comando git branch para verificar o nome do ramo em que você está:
git branch
Agora você está no seu novo ramo, use o comando git checkout novamente para mudar para o seu ramo principal:
git checkout Main
Em seguida, use o comando git pull para importar quaisquer alterações que sua equipe possa ter feito e atualizar seu ramo principal local:
git pull
Agora, use git checkout novamente para mudar para o novo ramo que você deseja mesclar com o ramo principal:
git checkout <your specified branch>
Agora é hora de usar o comando git merge. Isso pegará a versão atual do seu ramo principal e mesclará com seu ramo de desenvolvimento:
git merge Main
O resultado da mesclagem terá a versão mais recente do código mais a funcionalidade que você desenvolveu.
Outras maneiras de mesclar ramos Git
Depois de mostrar como mesclar um novo ramo com nosso ramo principal, vamos conferir outras maneiras de mesclar ramos Git que você pode precisar usar.
O que é uma mesclagem avanço rápido?
A fast-forward merge is another way to merge multiple commits on one branch with one command rather than merging them all manually. Another advantage of using a fast-forward merge is that it will combine the histories of multiple commits while squashing the commit history.
Vamos supor que temos um ramo de funcionalidade à frente do ramco principal por vários commits. Queremos mesclar todos esses commits sem ter que mesclá-los manualmente um por um. Neste caso, vamos usar uma mesclagem de avanço rápido.
Em nosso exemplo, vamos começar escrevendo algum código e adicionando um novo commit ao nosso ramo com os comandos git add e git commit:
git add <filename>
git commit –m “added a thing”
Agora, vamos adicionar outro commit ao nosso novo ramo usando os mesmos comandos mais uma vez:
git add <filename>
git commit –m “added another thing”
Em seguida, queremos enviar esses dois commits para nosso repositório remoto sem precisar fazer dois envios. Para fazer isso, precisamos usar o -ff no comando merge do git
git merge --ff
Isso mesclará ambos os commits ao mesmo tempo em um e fará com que seu código alcance o ramo principal.
O que é uma mesclagem de 3 vias?
Imagine um caso em que sua equipe de desenvolvimento criou novas funcionalidades em dois ramos separados. Agora você está pronto para atualizar os ramos e mesclá-los no ramo principal para que este último esteja pronto para enviar código para um repositório remoto.
Para garantir que as novas funcionalidades estejam funcionando corretamente juntas, é uma boa ideia mesclar os ramos de funcionalidades entre si e depois fazer alguns testes. Uma mesclagem de 3 vias nos permitirá combinar dois ramos separados com seu ancestral comum.
Vamos seguir os passos necessários para fazer uma mesclagem de 3 vias para o ramo alvo. No exemplo abaixo, começaremos criando um novo ramo, adicionando dois commits a ele, e em seguida, combinaremos com nosso ramo principal usando uma mesclagem de 3 vias.
Primeiro, vamos criar um ramo ‘nova-funcionalidade’ e alternar automaticamente para ele com o comando git checkout. Especificar -b com este comando faz com que um novo ramo seja criado:
git checkout -b new-feature main
Em seguida, adicionamos alguns arquivos e um novo commit ao nosso ramo com os seguintes comandos:
git add <file>
git commit -m "Start a feature"
Em seguida, adicionamos mais um commit ao nosso novo ramo com os seguintes comandos:
git add <file>
git commit -m "Finish a feature"
Depois de adicionar novo código ao nosso novo ramo, é preciso imaginar uma situação em que nosso ramo principal também continua a evoluir. Primeiro, vamos alternar de volta para ele com o comando git checkout:
git checkout main
Em seguida, adicionaremos um novo commit ao nosso ramo principal:
git add <file>
git commit -m "make some changes to Main"
Agora, queremos mesclar o ramo ‘nova-funcionalidade’ que criamos anteriormente com nosso ramo principal atualizado. Como o trabalho continuará em nosso ramo principal, vamos finalizar excluindo o ramo ‘nova-funcionalidade’ com o comando git branch.
git merge new-feature
git branch -d new-feature
Agora, mesclamos nossos dois ramos com um ancestral comum em nosso ramo principal. Este último está agora pronto para ser mesclado em seu repositório remoto e incrementar ainda mais nosso projeto de software, veremos como fazer isso em seguida.
Como mesclar um ramo do Git em um repositório remoto
Às vezes, você pode precisar mesclar um branch em um repositório remoto. Vamos seguir os passos sobre como realizar isso.
Vamos imaginar uma situação em que você escreveu um novo código para uma nova funcionalidade que seu proprietário de produto queria criar. Após testar seu código e revisá-lo com seu proprietário de produto, você está pronto para mesclar seu trabalho árduo no repositório remoto de sua equipe.
Como mencionado anteriormente, você nunca deve ser capaz de enviar seu código diretamente para o branch principal. Você sempre deve respeitar o fluxo de trabalho do Git que detalhamos no início deste guia.
Após revisar o processo do Git, vamos mesclar seu código. Continuando de onde paramos, agora temos um branch atualizado: As últimas atualizações do branch principal foram puxadas para baixo em seu repositório local.
Você está agora na entrada do repositório remoto. Como você chega lá? Simples, vamos usar alguns comandos git a mais.
Como uma boa prática, você sempre deve verificar o status do seu branch com o comando git status. Este comando mostrará quais arquivos foram adicionados, removidos, rastreados ou não rastreados.
git status
Você também deve verificar se você adicionou arquivos não rastreados. Nesse caso, você precisa adicioná-los para que sejam rastreados e adicionados ao commit.
Você pode usar o comando git add para adicionar todos os arquivos que você criou no seu desenvolvimento. Agora, talvez você precise escrever alguns nomes de arquivos se quiser adicionar arquivos específicos. Se você deseja adicionar todos os arquivos, use “.” para adicionar todos os arquivos.
Em seguida, usaremos o comando git commit para fazer o commit de todos os arquivos que adicionamos na etapa anterior. Você precisará usar a flag -m para escrever uma mensagem, caso contrário, você será direcionado para o modo de edição de texto para escrever uma mensagem, o que não é um processo simplificado.
Para a sua mensagem, você pode escrever uma breve nota sobre o que você fez. Por exemplo, “criei um novo recurso legal e adicionei um novo ícone ao menu e corrigi bugs.”
git commit -m “<your commit message goes here>”
Por fim, você pode usar o comando git push para enviar seu branch para o repositório remoto.
git push --set-upstream origin <<your branch name>>
Agora, após enviar seu branch, você precisará acessar o GitHub ou onde seus repositórios remotos estão hospedados, encontrar seu último envio e clicar em Criar pull request.
Ao clicar neste botão, você será levado a uma página para adicionar revisores e membros da sua equipe que aprovarão ou recusarão sua solicitação de merge. No segundo caso, eles serão capazes de adicionar comentários sobre o que precisa ser corrigido antes de permitir que você faça o merge do seu branch no branch principal remoto.
Uma vez que a revisão estiver completa e sua solicitação de mesclagem for aprovada, o botão Mesclar estará disponível. Clique neste botão para iniciar a mesclagem. Se a mesclagem for bem-sucedida, você receberá uma mensagem confirmando que seu novo código foi adicionado.
Parabéns! Você entendeu o básico para usar o comando de mesclagem do git!
Conclusão
O git merge é um comando poderoso que permitirá a você e sua equipe usar ramos diferentes para trabalhar em novas funcionalidades e depois reuní-los em seu repositório principal.
Você aprendeu os passos corretos necessários para criar ramos, mesclá-los, adicionar arquivos e commits a eles, e, o mais importante, enviar esses ramos para um repositório remoto. Além disso, agora você entende como fazer uma mesclagem avançada para combinar vários ramos relacionados usando um único comando, o que pode realmente ajudar a tornar qualquer trabalho de desenvolvimento mais eficiente.
O Git é uma ferramenta poderosa que pode fazer muitas coisas. Quanto mais você aprender sobre os diferentes comandos que pode usar, melhor você se tornará como desenvolvedor. Agora que você aprendeu tudo o que precisa saber sobre mesclar ramos, é hora de procurar aprender outros comandos. Boa sorte em sua jornada para dominar o Git!