Fusão no Git Simplificada: Mesclando Branches Como um Profissional – techsyncer

Mesclar branches no Git pode ser uma tarefa assustadora às vezes, mas o comando git merge simplifica significativamente o processo. Neste tutorial, você aprenderá os fundamentos de combinar branches usando o git merge, emparelhado com o GitHub, uma ferramenta líder de gerenciamento de projetos.

Vamos começar essa jornada pelo mundo do Git e GitHub, focando no poderoso comando git merge.

Pré-requisitos para Dominar o Git Merge

Antes de mergulhar nas complexidades do git merge, certifique-se de ter a seguinte configuração:

Git (Versão 2.25.1 usada neste tutorial) – Faça o download no site oficial do Git.
A GitHub account – Sign up at GitHub.
Uma máquina Ubuntu (Ubuntu 20.04 é usado aqui, mas qualquer sistema operacional com Git será suficiente).

Inicializando um Projeto para o Git Merge

Para usar efetivamente o git merge, você primeiro precisa de um projeto Git. Vamos configurar um projeto de demonstração para a prática.

1. Comece criando um novo diretório chamado ~/git-demo e acesse-o:

mkdir git-demo && cd git-demo

2. Crie um arquivo index.html no diretório ~/git-demo com o seguinte conteúdo. Este arquivo HTML básico exibe uma mensagem sobre começar com git merge.

<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Git Merge Demo</title>
</head>
<body>
    <h4>Let's get started with git merge</h4>
</body>
</html>

3. Inicialize um novo repositório Git no diretório do seu projeto:

O comando git init é usado para converter um projeto existente e sem versionamento em um repositório Git ou para iniciar um novo projeto com Git.

git init

Initializing a Git repository for git merge

4. Confirme a criação da pasta .git no diretório do seu projeto. Esta pasta é onde o Git rastreia as mudanças:

ls -la

Verifying the existence of the GIT repository in the directory.

5. Implemente o comando git add para preparar suas mudanças no projeto. Ao preparar o arquivo index.html, você está o preparando para o próximo commit no fluxo de trabalho do Git.

git add index.html

6. Use git status para confirmar que seu arquivo está corretamente preparado. Este comando fornece uma visão geral do estado atual do seu diretório de trabalho.

git status

Confirming the staging of changes for git merge.

7. Em seguida, faça o commit das suas mudanças usando git commit. Este comando salva suas mudanças preparadas no repositório local, marcando um passo significativo na sua história de versões.

git commit -m "initial commit"

Executing the initial commit in preparation for git merge.

Defina sua identidade Git com: git config --global user.email "[email protected]" e git config --global user.name "Seu Nome" se estiver usando o Git pela primeira vez.

8. Revise o histórico de commits com git log. Este comando ajuda a acompanhar as mudanças e é vital ao se preparar para um git merge.

git log

Checking commit history before performing git merge.

9. Confirme a existência de branches no seu repositório com git branch. Este passo é crucial antes de realizar um git merge.

Nota: A branch padrão é chamada ‘main’ nas versões recentes do Git, substituindo ‘master’.

git branch

Listing all branches in preparation for git merge.

Criando um Branch para o Git Merge

Com a sua configuração inicial do Git completa e o primeiro commit feito, é hora de criar um novo ramo. Este ramo será usado para demonstrar o processo de git merge de forma eficaz.

1. Atualize o arquivo index.html com novo conteúdo para demonstrar as mudanças no seu ramo. Esta versão inclui campos de entrada de usuário, preparando-se para uma demonstração de git merge.

<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Git Merge Demo</title>
</head>
<body>
    <h4>Enhancing Git Merge Skills</h4>
    <form action="">
      <input type="text" name="username" placeholder="Username" />
      <input type="password" name="password" placeholder="Password" />
    </form>
</body>
</html>

2. Verifique o status do seu repositório com git status para visualizar as mudanças em index.html. Deve indicar que o arquivo está modificado e não está em staged, pronto para os próximos passos no processo de git merge.

Inspecting repository changes for git merge.

3. Crie um novo ramo chamado “form” com git checkout -b form. Este comando não apenas cria o novo ramo, mas também muda seu ramo de trabalho para “form”, essencial para implementar git merge.

git checkout -b form

4. Confirme a criação do novo ramo executando git branch. Agora você deve ver tanto os ramos “form” quanto “master”, com “form” como o ramo ativo indicado por um asterisco (*).

git branch

Confirming the active ‘form’ branch for git merge.

5. Stage e faça commit das suas mudanças para o ramo form. Esta ação garante que o ramo form reflita as atualizações recentes feitas no arquivo index.html, preparando o terreno para um git merge eficaz.

## Etapa para preparar o arquivo atualizado
git add index.html

## Confirmar as novas alterações
git commit -m "Added user input fields to form"

Committing updated index.html to the ‘form’ branch for git merge.

Mesclando Ramificações Locais com Git Merge

Agora que você possui ramificações distintas no seu repositório do GitHub, o próximo passo é mesclá-las. Esta seção foca na fusão de ramificações localmente utilizando o comando git merge, uma operação fundamental do Git.

1. Para iniciar a mesclagem, mude para a ramificação master, que receberá as atualizações da ramificação form:

git checkout master

2. Uma vez na ramificação master, execute git merge form para combinar as mudanças da ramificação form na master. Este é um passo crucial no processo de git merge.

git merge form

Successfully merging branches using `git merge`.

3. Confirme a mesclagem garantindo que você está na ramificação master e verificando que o conteúdo do arquivo index.html foi atualizado.

# Confirmar ramificação atual
git branch
# Verificar conteúdo mesclado
cat index.html

Reviewing *index.html* content post `git merge`.

Otimizando com Git Squash

O Squash no Git é uma técnica usada para limpar o histórico de commits. Quando você tem múltiplas mensagens de commit que não são necessárias individualmente, o squash permite combinar estas em um único commit abrangente. Esta prática é especialmente útil ao se preparar para um git merge.

Vamos explorar o processo de squash fazendo mais alterações no arquivo index.html na ramificação form, e então esmagar essas mudanças.

1. Volte para o ramo form para fazer alterações adicionais:

git checkout form

2. Modifique o index.html adicionando um cabeçalho de formulário. Esta etapa criará uma alteração que posteriormente será mesclada durante a união:

<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    <h4>Mastering Git Merge with Form Updates</h4>
    <form action="">
      <h4>Account Details</h4>
      <input type="text" name="username" placeholder="Username" />
      <input type="password" name="password" placeholder="Password" />
      <button>Submit</button>
    </form>
</body>
</html>

3. Stage e commit das alterações com uma mensagem clara descrevendo a atualização:

git add index.html
git commit -m "Enhanced form with a header for git merge"

Staging and committing changes for squashing in `git merge`.

4. Aprimore o index.html no ramo form adicionando um novo campo de entrada. Esta modificação faz parte da preparação para uma união eficaz do git merge.

<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Git Merge Example</title>
</head>
<body>
    <h4>Practicing Git Merge</h4>
    <form action="">
      <h4>Enter account details</h4>
      <input type="text" name="fullname" placeholder="Full Name" />
      <input type="text" name="username" placeholder="Username" />
      <input type="password" name="password" placeholder="Password" />
      <button>Submit</button>
    </form>
</body>
</html>

5. Stage e commit dessas alterações com uma mensagem distinta, garantindo que cada passo do seu trabalho seja claramente documentado para a próxima união do git merge.

git add index.html
git commit -m "Enhanced form with an additional input field"

Adding another input field to index.html for `git merge`.

6. Em seguida, insira um elemento de parágrafo sob o formulário em index.html, modificando ainda mais o arquivo em preparação para um git merge.

<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Git Merge Practice</title>
</head>
<body>
    <h4>Let's get started with git merge</h4>
    <form action="">
      <h4>Enter account details</h4>
      <input type="text" name="fullname" placeholder="Full Name" />
      <input type="text" name="username" placeholder="Username" />
      <input type="password" name="password" placeholder="Password" />
      <button>Submit</button>
    </form>
    <p>Already a user?</p>
</body>
</html>

7. Novamente, stage e commit das alterações, usando uma mensagem que capture a essência desta atualização, crucial para o processo de git merge.

git add index.html
git commit -m "Added user status paragraph to form"

Further modifying index.html for `git merge`.

8. Utilize o git rebase no modo interativo para visualizar e editar seus commits recentes. Esta etapa é essencial no processo de unir commits para um git merge limpo.

git rebase -i HEAD~3

9. No modo interativo, escolha reword o primeiro commit e squash os subsequentes. Esta ação consolida seu histórico de commits, tornando seu git merge mais limpo e organizado.

Preparing commits for squashing in `git merge`.

10. Depois de reescrever e salvar, atualize a mensagem do commit consolidado para refletir as mudanças cumulativas. Esta etapa finaliza o processo de união, preparando-o para um git merge simplificado.

Finalizing the commit message for `git merge`.

Confirme o sucesso da sua operação de esmagamento, que é uma parte integral do processo de git merge ao lidar com múltiplas mensagens de commit.

Para esmagamento e mesclagem simultâneos, use git merge --squash. Esta técnica mescla e esmaga o ramo form no ramo master, combinando eficientemente os commits.

git merge --squash form

Executar o comando git merge --squash combina as alterações do ramo form no master enquanto condensa todos os commits em um. Esta abordagem faz parte das estratégias eficazes de git merge.

Executing `git merge` with squash option.

Implementando Avanço Rápido no Git Merge

Para um histórico de commit simplificado, o avanço rápido é um método ideal, especialmente para atualizações menores ou correções de bugs. Ele permite mesclar ramos sem commits de mesclagem adicionais, mantendo um histórico limpo e linear, crucial para processos eficientes de git merge.

O avanço rápido ocorre quando não há divergência no ramo base, normalmente o master, permitindo uma integração perfeita dos históricos e atualizações de ponteiros.

1. Mude para o ramo form para iniciar o processo de avanço rápido:

git checkout form

2. Crie e atualize um arquivo JavaScript, como index.js, no ramo form, adicionando e commitando as alterações:

git add index.js
git commit -m "Added JavaScript functionality"

3. Por fim, faça a mesclagem do ramo form no master usando uma abordagem de avanço rápido. Este passo alinha o ramo master com as últimas alterações do ramo form, criando um caminho de git merge suave e linear.

git checkout master
git merge form

Conclusão

Este tutorial guiou você por várias técnicas para combinar ramos usando git merge. Desde o esmagamento de commits até o avanço rápido, esses métodos aprimoram sua capacidade de gerenciar projetos colaborativamente no Git.

Agora, equipado com essas habilidades, considere contribuir para projetos colaborativos no GitHub, aplicando seu conhecimento de git merge em cenários do mundo real.