Gestão e administração de filiais no GIT

UMA galho em Git é uma ramificação do nosso repositório, é uma forma de gerar um caminho alternativo para o caminho principal. Isso nos permite explorar novas soluções sem ter que modificar a base do programa ou aplicativo que estamos executando.
No entanto, o conceito de galho Não está muito claro quando começamos a usar essa ferramenta que controla as versões de nossos projetos. Normalmente em outros sistemas de controle de versão as ramificações de um projeto com este conceito não são tomadas.
Muitos já estarão usando Git e eles não prestaram mais atenção a galhos, e de certa forma é compreensível, pois ao lidar com um único galho e se o desenvolvimento estiver sendo realizado por uma única pessoa, não deve haver nenhum inconveniente.
Mas e se essa pessoa quiser testar alguns recursos experimentais que podem fazer com que seu projeto falhe ou simplesmente afetar a estabilidade do projeto, alguns dirão que um Forquilha do projeto e continuar experimentando e, se a melhoria for bem-sucedida, pense em incorporar o que foi feito na bifurcação ao projeto principal. Este é realmente um trabalho um pouco longo e desnecessário.
No caso acima, basta criar um novo galho dentro do projeto em questão, podemos fazer todas as alterações e experimentações desejadas e, no final, simplesmente fazendo um fundir ou fusão com o galho inicial ou principal já teremos juntado todas as nossas alterações.
Outro casoOutro caso é quando temos uma equipe de trabalho onde duas pessoas trabalhando no mesmo código podem gerar conflitos, é aqui que Git traz à tona seu poder. Podemos criar uma estrutura de três ramos por exemplo, um filial para cada desenvolvedor e um ramo de unificação. Desta forma, cada desenvolvedor pode pegar suas mudanças e quando sentir que pode contribuir com o projeto, eles as enviam para o galho de unificação e, portanto, a outra pessoa ou os outros membros da equipe podem acessá-los.
Já entendemos os motivos que nos levam a usar galhos e estamos familiarizados com o conceito, agora vamos ver uma parte que é vital para o uso desse recurso do Git e é dar um nome ao nosso galho.
Nome da filialPelo nome é que saberemos onde nos encontramos no momento, esse nome é totalmente arbitrário, ou seja, cada usuário do Git você pode nomear o seu galhos como você deseja dentro do seu projeto. Usualmente Git criar uma galho chamado mestre Por padrão, é geralmente aquele que contém a versão estável e livre de bugs do projeto, no entanto, podemos renomeá-lo ou até mesmo excluí-lo se quisermos, embora seja aconselhável não fazê-lo.
Como podemos usar curingas de pesquisa, podemos nomear nosso galhos hierarquicamente, por exemplo, Imp_Bug / 89 ou Impl_Bug / 23. Isso nos permite localizá-los e organizá-los por temas. Vamos ver como levamos o explicado para nosso repositório de teste:
Neste caso, temos um mestre de filial e criamos vários galhos que são para resolver bugs, se executarmos o comando ramo git no console Git dentro da pasta do nosso projeto obteremos uma lista com todos os ramos existentesVamos ver como fica quando o executamos:

Em seguida, vemos a lista de todos os nossos galhos e em uma cor diferente vemos o galho em que estamos no momento certo. Mas e se tivermos muitos galhos e precisamos filtrar apenas o ramos de resolução de bugBem, é aí que a pesquisa curinga entra em jogo. Por exemplo, se quisermos pesquisar desta forma, devemos fazer um comando semelhante ao seguinte:

git show-branch impl_bug / *

Vamos ver como fica em nosso console:

Podemos então notar que todos os galhos e de um lado temos o comentário do último comprometer-se isso foi feito neles.
Porque o nomeação de filial É algo totalmente arbitrário e na opinião do usuário, muitas vezes há confusão dentro de uma equipe, por isso podemos seguir algumas recomendações e melhores práticas, assim seremos melhores usuários dentro da ferramenta:

• Embora possamos usar o símbolo / no nome de nossas ramificações, esse não pode ser o caractere final de um nome.
• Não podemos colocar um ponto (.) depois de uma barra (/).
• Não podemos colocar dois pontos em uma linha (… ) dentro de um nome.
• Não devemos usar caracteres especiais (~ : ? * [ ) uma vez que esses caracteres têm um significado dentro da sintaxe de Git e eles podem estar sujeitos a erros.
• Também não devemos ter espaços em branco ou caracteres de controle ASCII.

Se seguirmos essas diretrizes, manteremos o uso adequado em nosso repositório, assim como os outros membros da equipe nos agradecerão por tornar a vida mais fácil para eles.
Se tivermos um lista de ramos e nós estamos em um galho mas queremos ir para outro, só temos que usar o seguinte comando:

git checkout branch-name

Com isso vamos mudar galho imediatamente, podendo assim trabalhar em várias seções do projeto sem problemas. Vamos ver como podemos trocar ramos em nosso repositório de teste:

Como notamos, é algo bastante simples, no entanto, se fizermos uma alteração neste branch e não fizermos comprometer-se ao tentar mudar para outro, obteremos um erro e Git Diz-nos que devemos fazer algo porque, do contrário, as mudanças podem ser perdidas:

Quando esse problema acontece, devemos fazer um comprometer-se e então passar para o próximo galho nós veremos o conteúdo do outro galho.
Para criar um novo ramo, continuaremos usando o comando Confira, no entanto, neste caso, devemos adicionar o opção -b, com isso faremos uma cópia do branch atual e geraremos um totalmente novo. Vamos ver como fica em nosso console:

Nós notamos como uma vez criou a nova filial imediatamente Git nos leva até ele e podemos começar a trabalhar diretamente.
Embora não seja muito comum, há casos em que desejamos deletar um ramo de nosso repositório e Git permite-nos fazê-lo, só que não podemos eliminar o ramo em que nos encontramos, para evitar inconsistências com a ferramenta. Para realizar esta operação, é tão fácil quanto aplicar o seguinte comando:

git branch -d branch-name

RestriçõesNo entanto, existem algumas restrições, por exemplo, não podemos excluir um galho o que tem compromete que o galho de onde estamos tentando apagar não tem, com ele Git ajuda a evitar a perda de informações, se quisermos excluir um ramo dessas características, devemos fazer fundir em nosso galho ou vá para um que tenha aqueles compromete.
Vamos ver como é a execução desse comando no console:

No final de sua execução, vemos como Git confirma a eliminação do ramo correspondente.
Há momentos em que tocamos a mesma linha em um arquivo em dois ramos diferentes, isso na hora de fazer fundir vai gerar um conflito para nós. Git Isso nos ajuda a estabelecer uma diferenciação do conflito dentro do arquivo, então, ao resolvê-lo, devemos fazer um novo comprometer-se e um novo fundir. A diferenciação é exibida da seguinte forma no arquivo em questão:

 qualquer linha <<<<<< >>>>>> dev: NewChange 

Se quisermos resolver o conflito, devemos excluir o conteúdo de Git, isto é, as linhas com <<<<< Y >>>>, então deixamos a mudança que queremos ou unificamos tudo, fazendo isso já Git não nos apresentará mais com o erro e seremos capazes de fazer o fundir usualmente.
ImportanteUma das coisas que é importante fazer é gerar um nomenclatura compartilhada, isto é, estabelecer uma estrutura de nomes sob a qual o galhos dependendo de sua função dentro do projeto, dessa forma teremos muito mais ordem, é claro que essa nomenclatura deve seguir as melhores práticas mencionadas no início do tutorial.
Com isso terminamos este tutorial, poderemos tirar muito mais do nosso repositório em Git e com isso gerir a nossa equipa de uma forma excelente. Já devemos ter a base coberta para a gestão de galhos em Git, com isso podemos fazer uma gestão adequada das nossas mudanças para que possamos minimizar os conflitos, principalmente quando trabalhamos em equipes de duas ou mais pessoas.Gostou e ajudou este tutorial?Você pode recompensar o autor pressionando este botão para dar a ele um ponto positivo