Git Branch: como usar e gerar ramificações

Os recursos de ramificações oferecidos pelo Git Branch ajudam os desenvolvedores a reduzir os bugs da versão final do software

O Git Branch oferece recursos de ramificação, um aspecto fundamental para o fluxo de trabalho de controle de versão. A ferramenta reduz a possibilidade de ocorrência de erros na versão primária da base de código e também diminui a ocorrência de bugs e outros comportamentos adversos potenciais no software.

O que é o Git Branch? 

O Git Branch é um recurso que permite aos desenvolvedores testarem novas ideias sem restrições para serem adicionadas ao código principal depois de se tornarem estáveis. Além disso, o Git Branch possibilita que as equipes trabalhem de forma remota. Portanto, os profissionais podem continuar a contribuir criativamente para o projeto de forma eficiente.

O que é ramificação?

A ramificação, ou branch, é uma bifurcação do código-fonte que cria uma linha independente de desenvolvimento. O recurso funciona como um controle de origem que permite separar a evolução da programação em diferentes subdivisões. Isso torna possível que os profissionais escrevam o código principal de forma livre, sem afetar o trabalho de outro.

No início do trabalho com o Git, existe apenas uma ramificação primária. As subdivisões podem ser criadas a partir do código principal ou de algum “galho”. A ferramenta permite a criação de quantos ramais forem necessários. Dessa forma, o recurso viabiliza testar novos recursos e corrigir eventuais erros sem afetar o código-fonte do software.

Como usar os comandos do Git Branch

A criação e o gerenciamento das ramificações no Git são simples e podem ser feitas a partir da linha de comandos no terminal ou por meio de um servidor de hospedagem de projetos. Contudo, quanto mais subdivisões forem criadas, mais difícil será para gerenciar o recurso.

 Confira quais são os comandos e as funções para trabalhar com esta poderosa ferramenta.

Verificando as ramificações criadas

O comando “git branch –list” permite listar as ramificações que foram criadas no projeto. Caso não haja subdivisão, o terminal não vai apresentar nenhuma informação. Se houver, elas serão listadas. O comando pode ser utilizado com a opção “-r”, que mostra as ramificações de rastreamento remoto ou “-a”, para listar tanto as ramificações locais quanto remotas.

Criando ramificações

A maneira mais fácil de criar uma ramificação Git é usar o comando “git branch”. Em seguida, é preciso apenas especificar o nome da ramificação que deseja criar:

$ git branch <nome-da-ramificação>

Inicialmente, a ramificação local fica apenas acessível ao dispositivo físico onde foi desenvolvida. Uma subdivisão criada localmente pode ser enviada um repositório remoto, com o comando:

$ git checkout <nome>

Caso o “galho” local não exista, a filial remota pode ser criada diretamente usando o parâmetro “-b” do comando checkout:

$ git checkout -b <nome>

Alterando o nome

Depois de criada, o nome da ramificação pode ser alterado, sempre que necessário. Para tanto, basta digitar o comando no terminal:

$ git branch -m <nome-antigo> <nome-novo>

Excluindo ramificações

Se a codificação der errado ou se tornar desnecessária para o desenvolvimento do software, a ramificação pode ser facilmente excluída usando o parâmetro “-d”.

$ git branch -d <nome>

Entretanto, quando a ramificação tem alterações (commits) que não foram mesclados em outras subdivisões ou não foram enviados para repositórios remotos, o Git se recusa a excluir o “galho” para proteger o código contra a perda acidental de seus dados. Caso a exclusão seja realmente necessária, basta usar a opção “-D” para forçar o apagamento.

$ git branch -D <nome>

Já para excluir uma ramificação remota, é necessário usar o comando git push:

$ git push origin –delete <nome>

Mesclando ramificações

A mesclagem do Git permite juntar duas ou mais ramificações por meio de um commit, depois de concluir e testar o código desenvolvido de forma separada. Assim, o branch fica disponível para toda a equipe. O histórico de sua ramificação de recurso é preservado e apenas a ramificação de destino é alterada.

Antes de mesclar, é importante fazer um “git fetch” para reunir informações atualizadas sobre o repositório remoto:

$ git fetch –all

Em seguida, é necessário ir até a ramificação na qual as alterações devem ser mescladas e executar o git checkout:

$ git checkout principal

Finalmente, é possível usar o comando “merge myfeature” na ramificação primária.

$ git merge myfeature

Se a mesclagem for bem-sucedida e o trabalho em myfeature estiver completo, a ramificação experimental poderá ser excluída, pois todas as alterações estão integradas ao código principal.

Comando rebase

O “rebase” é um conceito avançado no Git. O recurso é semelhante à mesclagem. Ambos os comandos pegam commits de uma ramificação e os colocam em outra. Contudo, o “rebase” apaga o histórico da ramificação após mesclar o código secundário no principal. Para usar o comando, basta executar as linhas:

$ git checkout myfeature

$ git rebase main

Comece a experimentar com o Git Branch

A criação e exclusão de ramificações é um dos principais benefícios que os desenvolvedores desfrutam quando mudam dos sistemas tradicionais de controle de versão para o Git. Se os experimentos falharem, basta simplesmente excluir a ramificação. E se eles tiverem sucesso, é só mesclá-los ao código-fonte para avançar no desenvolvimento do software.