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

Mesclar ramos no Git pode ser uma tarefa desafiadora às vezes, mas o comando git merge simplifica significativamente o processo. Neste tutorial, você aprenderá o essencial sobre combinar ramos usando o git merge, em conjunto com o GitHub, uma ferramenta líder de gerenciamento de projetos.

Vamos iniciar esta jornada no mundo do Git e GitHub, focando no poderoso comando git merge.

Pré-requisitos para Dominar o Git Merge

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

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

Inicializando um Projeto para o Git Merge

Para usar efetivamente o git merge, você precisa primeiro 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 navegue até ele:

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 o 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 é utilizado para converter um projeto existente, sem controle de versão, 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 adicionar suas mudanças no projeto. Ao adicionar o arquivo index.html, você está preparando-o para o próximo commit no fluxo de trabalho do Git.

git add index.html

6. Utilize o git status para confirmar que seu arquivo está corretamente adicionado. Este comando fornece uma imagem instantânea 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 adicionadas 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.

Configure sua identidade no 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 seu histórico de commits com git log. Este comando ajuda a acompanhar as mudanças e é vital ao 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: O branch padrão é nomeado como ‘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 um 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 estado do seu repositório com git status para visualizar as mudanças no arquivo index.html. Deve indicar que o arquivo está modificado e não está em stage, 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 só 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. Estageie 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.

## Encenar 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.

Fusão de Branches Locais com Git Merge

Agora que você tem branches distintas em seu repositório GitHub, o próximo passo é mesclá-las. Esta seção concentra-se em mesclar branches localmente usando o comando git merge, uma operação fundamental do Git.

1. Para começar a mesclagem, mude para a branch master, que receberá as atualizações da branch form:

git checkout master

2. Uma vez na branch master, execute git merge form para combinar as alterações da branch 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 branch master e verificando que o conteúdo de index.html foi atualizado.

# Confirmar branch atual
git branch
# Verificar conteúdo mesclado
cat index.html

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

Otimizando com Git Squash

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

Vamos explorar o processo de “squashing” fazendo mais alterações no arquivo index.html na branch form, e então esmagando essas alterações.

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 mais tarde vamos mesclar durante o 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>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 faça 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 um git merge eficaz.

<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 faça commit dessas alterações com uma mensagem distinta, garantindo que cada etapa do seu trabalho esteja claramente documentada para o próximo 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 faça 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 git rebase em modo interativo para visualizar e editar seus commits recentes. Esta etapa é essencial no processo de unificar commits para um git merge limpo.

git rebase -i HEAD~3

9. No modo interativo, escolha reword para o primeiro commit e squash para 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. Após reescrever e salvar, atualize a mensagem do commit consolidado para refletir as alterações acumulativas. Esta etapa finaliza o processo de unificaçã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 esmagar e mesclar simultaneamente, use git merge --squash. Esta técnica mescla e esmaga o ramo form no ramo master, combinando eficientemente os commits.

git merge --squash form

Ao executar o comando git merge --squash, são combinadas as alterações do ramo form em master, enquanto todos os commits são condensados em um único. Esta abordagem faz parte de estratégias eficazes de git merge.

Executing `git merge` with squash option.

Implementando Avanço Rápido no Merge do Git

Para um histórico de commits simplificado, o avanço rápido é um método ideal, especialmente para atualizações menores ou correções de bugs. Permite mesclar ramos sem commits de merge 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, possibilitando uma integração suave de 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, encenando e confirmando as alterações:

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

3. Por fim, faça o merge do ramo form em 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ê através de várias técnicas para combinar branches usando git merge. Desde o esmagamento de commits até o avanço rápido, esses métodos melhoram 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.