Como criar e gerenciar branches no Git

Editado 2 meses atrás por ExtremeHow Equipe Editorial

GitRamificaçõesGestãoJanelasMacLinuxControle de versãoControle de VersãoDesenvolvimentoFluxo de TrabalhoColaboração

O Git é um poderoso sistema de controle de versão que ajuda os desenvolvedores a monitorar alterações em seu código e colaborar com outras pessoas. Uma das principais características do Git é o branching, que permite aos desenvolvedores trabalharem de forma independente em diferentes funcionalidades ou experimentos, afastando-se da base de código principal. Neste guia detalhado, aprenderemos como criar e gerenciar branches no Git.

Entendendo o branching no Git

No Git, um branch é simplesmente um ponteiro leve e móvel para um commit. O nome padrão do branch no Git é master (às vezes main em novos projetos). Quando você começa a fazer commits, é criado um branch master que aponta para o último commit realizado. Toda vez que você realiza um commit, ele avança automaticamente.

Os branches no Git são essencialmente uma parte do histórico de commits. Isso permite que o desenvolvedor mude de contexto facilmente e separe o trabalho em diferentes branches. Isso é útil para gerenciar o fluxo de trabalho e controlar o impacto de quaisquer alterações feitas. Por padrão, um branch no Git é criado e excluído mais facilmente do que em outros sistemas de controle de versão.

Criando um novo branch no Git

Para criar um novo branch no Git, você pode usar o seguinte comando:

git branch <branch-name>

Por exemplo, se você quisesse criar um branch nomeado feature-update, você digitaria:

git branch feature-update

Este comando criará um novo branch chamado feature-update. No entanto, você ainda estará no branch master. Para começar a trabalhar no novo branch, você precisa mudar para ele usando o seguinte comando:

git checkout feature-update

O Git então atualizará seu diretório de trabalho e apontará seu ponteiro de branch para o branch feature-update. Nas versões 2.23 do Git e posteriores, você pode usar o comando switch para simplificar o fluxo de trabalho:

git switch feature-update

Criando e alternando para um novo branch em um único comando

O Git fornece um atalho para criar um novo branch e alternar para ele em um único comando: checkout com a opção -b.

git checkout -b <branch-name>

Usando isto, você pode criar um novo branch e alternar para ele:

git checkout -b feature-update

Ou usando o comando switch em versões mais recentes:

git switch -c feature-update

Listando branches

Para ver todos os branches no seu repositório, você pode usar o comando git branch:

git branch

Este comando listará todos os branches no repositório e marcará o branch atual com um asterisco (*).

Renomeando um branch

Às vezes, você pode precisar renomear um branch. Você pode renomear o branch atual usando o seguinte:

git branch -m <new-branch-name>

Se você quiser renomear um branch no qual não está atualmente, use:

git branch -m <old-branch-name> <new-branch-name>

Este comando irá renomear o branch especificado.

Excluindo um branch

Depois de terminar o trabalho em um branch, você pode querer excluí-lo. Excluir um branch no Git é muito fácil. Primeiro, certifique-se de que você tenha alternado para outro branch que não deseja excluir.

Para excluir um branch, use:

git branch -d <branch-name>

Este comando irá excluir o branch especificado. Se o branch que você está considerando excluir tiver alguma alteração não mesclada, o Git impedirá que você o exclua. Nesses casos, se você tiver certeza, poderá forçar a exclusão:

git branch -D <branch-name>

Mesclagem de branches

Depois de terminar o trabalho em uma funcionalidade ou melhoria em um branch, você provavelmente desejará integrar essas alterações em outro branch, como master ou main. Esse processo é chamado de mesclagem.

Alterne para o branch no qual você deseja mesclar. Por exemplo, se você quiser mesclar feature-update em master, certifique-se de que está no branch master:

git checkout master

Então, execute o seguinte comando:

git merge feature-update

O Git irá pegar os commits do branch feature-update e integrá-los ao branch master. Se não houver conflitos, esse processo será simples. Se houver quaisquer conflitos, o Git interromperá a mesclagem e solicitará que você os resolva manualmente.

Resolvendo conflitos de mesclagem

Conflitos de mesclagem ocorrem quando alterações foram feitas na mesma parte do código em ambos os branches sendo mesclados. O Git destacará o código conflitante, e caberá ao desenvolvedor decidir o que manter, excluir ou reescrever.

Para resolver conflitos de mesclagem, abra os arquivos afetados e procure as linhas marcadas com <<<<<<< HEAD e >>>>>>>. Esses marcadores indicam as diferenças entre as alterações do branch existente e do branch sendo mesclado. Escolha quais alterações manter e faça os ajustes necessários.

Depois de resolver os conflitos, marque os arquivos como resolvidos:

git add <filename>

Finalmente, complete o processo de mesclagem aplicando as alterações:

git commit

Isso irá integrar as alterações e criar um novo commit de mesclagem para completar o processo de mesclagem.

Rebase de branches

Outra maneira de integrar mudanças é usar o rebase. O rebase envolve mover ou combinar uma sequência de commits em um novo commit base. Esta pode ser uma técnica poderosa para manter um histórico de projeto linear.

Para fazer rebase em um branch, primeiro mude para o branch que você deseja fazer rebase. Digamos que você queira fazer rebase de feature-update para master:

git checkout feature-update

Em seguida, execute o seguinte comando:

git rebase master

O Git irá reaplicar os commits de feature-update em cima de master, criando um histórico linear. Note que o rebase pode levar a alterações nos hashes dos commits, o que pode complicar as coisas se seu branch já tiver sido enviado a um repositório compartilhado.

Melhores práticas para branching no Git

• Use nomes de branches descritivos: Nomear branches de forma clara tornará mais fácil para outros entenderem seu propósito. Use nomes como feature/description ou fix/description.
• Mantenha branches de curta duração: Para evitar branches de longa duração que possam diferir muito, tente mesclá-los ou excluí-los assim que forem concluídos.
• Faça pulls com frequência: Pulls frequentes manterão seus branches atualizados com o desenvolvimento principal, reduzindo a chance de conflitos no momento da mesclagem.
• Evite fazer commits de seus arquivos de construção ou dependências: Em alguns fluxos de trabalho, arquivos gerados devem ser excluídos dos branches para evitar conflitos de mesclagem desnecessários e confusão.
• Mantenha a comunicação com sua equipe: Sempre mantenha a comunicação dentro da equipe, especialmente em projetos colaborativos, para garantir a mesclagem sistemática e reduzir as chances de conflito.

Conclusão

O modelo de branching do Git é incrivelmente flexível e poderoso, permitindo que desenvolvedores individuais ou equipes inteiras trabalhem em funcionalidades ou melhorias separadas sem impactar o projeto principal. Saber como criar, alternar e gerenciar de forma eficiente branches no Git, bem como entender estratégias de mesclagem e rebase, é crucial para qualquer fluxo de trabalho de desenvolvimento moderno.

Seguindo as melhores práticas e garantindo uma comunicação adequada entre as equipes, branches no Git podem aumentar significativamente a produtividade e agilizar o gerenciamento de projetos. Seja você um desenvolvedor trabalhando em um pequeno projeto pessoal ou colaborando com uma grande equipe, dominar os branches do Git é uma parte essencial do desenvolvimento de software moderno.

  Compartilhe Este Artigo

Se você encontrar algo errado com o conteúdo do artigo, você pode solicitar uma atualização