Administração do Sistema

Tutorial de ramificação Git para iniciantes

Tutorial de ramificação Git para iniciantes

A ramificação permite que o Git rastreie várias linhas de desenvolvimento. Isso essencialmente permite que você tenha várias versões do seu projeto em desenvolvimento ao mesmo tempo. Por exemplo, muitos projetos optarão por ter uma filial mestre estável, enquanto novos recursos ou correções de bugs são implementados em uma filial de desenvolvimento ou teste. Uma vez que os organizadores do projeto estivessem satisfeitos que as mudanças feitas no ramo de desenvolvimento atinjam o nível necessário de maturidade, eles podem optar por mesclar essas mudanças no ramo mestre.

Para muitos projetos maiores, esse ciclo geralmente será repetido indefinidamente. O benefício de implementar essa estratégia é que ela ajuda a reduzir a introdução de erros na versão primária da base de código e, portanto, reduz a ocorrência de bugs e outros potenciais comportamentos adversos no software. Simultaneamente, permite que os desenvolvedores testem novas idéias sem restrições. Portanto, eles podem continuar contribuindo de forma criativa para o projeto de maneira eficiente.

Neste tutorial, você aprenderá:

  • O que é ramificação
  • Como criar ramos
  • Como alternar entre ramificações
  • Como excluir galhos
  • Como mesclar galhos
  • Como gerenciar tags
  • Como usar tags para acompanhar a versão
  • Como trabalhar com ramos e tags em repositórios remotos
Tutorial de ramificação Git para iniciantes

Requisitos de software e convenções usadas

Requisitos de software e convenções de linha de comando Linux
Categoria Requisitos, convenções ou versão de software usada
Sistema Qualquer sistema operacional GNU/Linux
Programas Git
Outro Acesso privilegiado ao seu sistema Linux como raiz ou através do sudo comando.
Convenções # - requer que os comandos Linux sejam executados com privilégios root diretamente como usuário root ou por uso de sudo comando
$ - Requer que os comandos do Linux sejam executados como um usuário não privilegiado regular

Criando ramificações

Vamos examinar um exemplo rápido de como trabalhar com filiais, continuando com o projeto GIT inicial que criamos no tutorial Git anterior para iniciantes. Primeiro, faça do ProjectName seu diretório de trabalho atual. Agora vamos criar uma filial especificamente para trabalhar na documentação para o projeto. Emitir o seguinte comando para fazer desta nova filial.

$ Git Branch Docs

Agora, vamos dar uma olhada em todos os nossos ramos.

Ramo $ git

Simplesmente emitindo o ramo git O comando como acima exibe uma lista de todas as filiais em nosso repo Git. Você notará que o primeiro ramo é chamado mestre por padrão. No nosso caso, vemos o mestre filial e nossa filial de documentos recém -criados. Observe que o ramo atual em que estamos trabalhando é marcado por * E ainda é o ramo principal. Para começar a trabalhar na filial dos documentos, precisamos fazer o checkout da filial.

Alternando entre ramificações

$ git checkout docs

Agora que verificamos o documentos ramo, quaisquer alterações que fizemos afetarão esse ramo sozinho e o mestre a filial permanecerá intocada e, no estado exato de que estava antes de verificar o documentos filial.
Vamos criar um Leia-me.TXT Arquive o nosso projeto.

$ echo "Este é um programa simples do Hello World que foi criado durante um tutorial Git."> ReadMe.TXT

Agora que temos um arquivo ReadMe descritivo para documentação, vamos encaixá -lo e cometê -lo como aprendemos a fazer no tutorial Git anterior para o artigo de iniciantes.

$ git add readme.TXT $ Git Commit -m "Adicionado ReadMe to Docs Branch"

Agora que cometemos a mudança em nossa filial de documentos, podemos voltar para o ramo mestre, checando.

$ git checkout mestre

Vá em frente e liste o conteúdo do diretório.

$ ls

Você notará que o ramo principal não tem o Leia-me.TXT Arquivo porque no momento ele só existe na filial dos documentos. Isso demonstra como os dois ramos representam dois estados distintos de desenvolvimento.

Mesclagem de galhos

Agora, e se sentirmos que nossa documentação estiver completa e pronta para ser mesclada no ramo mestre? É aqui que o comando Git Merge é útil. Digite o seguinte comando para mesclar a filial dos documentos no ramo mestre.

$ Git Merge Docs

Liste o conteúdo do diretório e observe que o ramo principal agora contém o readme.arquivo txt.

$ ls

Se emitirmos

$ git log

Então vemos que o histórico de log dos dois ramos também foi fundido.

Verifique o log git

Excluindo galhos

Agora que concluímos nossa documentação e mesclamos a filial dos documentos com o ramo mestre, podemos excluir com segurança a filial do documento se quisermos. Para fazer isso, basta adicionar o -d sinalizador para o comando git ramo.

$ git ramo -d docs

Agora, temos apenas um ramo em nosso projeto novamente e isso reflete todas as mudanças que fizemos ao longo dela; incluindo a adição de um arquivo de leitura.

Marcação

Podemos querer ser capaz de ver e nos referir facilmente a um compromisso específico sem ter que usar seu ID de confirmação. Para conseguir isso, podemos usar o comando git tag para dar um nome memorável. No nosso caso, vamos nomear nosso comando do punho iniciar, nosso segundo compromisso fonte e nosso último compromisso Leia-me Para que, se precisarmos no futuro, podemos nos referir facilmente aos compromissos onde inicializamos o projeto, adicionamos o código -fonte e adicionamos um arquivo readme, respectivamente.

$ git tag init abbda7da6f6257effc7DA16766FFC464C4098A8E $ Git Fonte 41DCCEE5478129094C3CBBBCD08A26076A9A370B $ Git readme

Você pode notar que, para o último comando, não tivemos que especificar um ID de confirmação. Isso ocorre porque esse compromisso é a nossa cabeça atual e a cabeça atual é nomeada por padrão se um ID de confirmação não for fornecido. Poderíamos ter fornecido o ID de confirmação, se quiséssemos, mas teria sido desnecessário.

Se usarmos o comando tag sem argumentos, ele nos dará uma lista de todas as tags que estamos usando.

$ git tag

Se quisermos ver todas as tags, juntamente com as outras informações de comprometer, podemos emitir o Comando Familiar Log:

$ git log
Taggagem git

A partir de agora, quando queremos referenciar esses compromissos, podemos usar suas tags no lugar de seus IDs de confirmação. Assim como podemos verificar uma filial, também podemos verificar um compromisso específico. Se decidimos que queríamos verificar nossa primeira confirmação, agora poderíamos conferir usando sua tag.

$ git checkout init

A partir deste ponto, se decidimos que queremos criar um novo ramo que tenha sido em uma direção completamente diferente do nosso projeto original, poderíamos fazer isso fazendo algumas alterações aqui e emitindo o comando Switch com o sinalizador -c seguido pelo novo nome. Semelhante ao comando de checkout, o Switch muda as filiais, mas com o sinalizador -c, ele também pode criar simultaneamente uma nova ramificação.

 $ git switch -c New-name

Você também pode criar uma nova filial e mudar para ela com o comando de checkout da seguinte forma.

checkout $ git -B New-name

Use o que você preferir, mas é importante observar que, de acordo com as páginas do homem de Git, o comando Switch é experimental e sua funcionalidade pode mudar no futuro.

outras considerações

Estamos usando um exemplo muito simples para focar no próprio git, em vez do código que estamos gerenciando. Como resultado, as tags que usamos refletem um esquema de nomeação simples com base na introdução de recursos. No entanto, projetos maiores normalmente usam tags como um meio de acompanhar o controle de versão, marcando compromissos que correspondem a números específicos do ponto de liberação.

Por exemplo, versão1.0,
versão 2.0 etc. Também é importante observar que, quando você está empurrando suas alterações para um servidor remoto, novas ramificações e tags não são pressionadas por padrão e devem ser pressionadas especificamente usando os seguintes comandos.

$ git push origin new_branch_name $ git push origem tag_name $ git push origin -tags

O primeiro comando empurrará a filial especificada para o servidor remoto, o segundo empurrará a tag especificada para o servidor e o terceiro empurrará todas as tags para o servidor.
Outra coisa importante a ser observada sobre servidores remotos é que, se você clonou um repositório remoto, a filial principal clonou para sua máquina local, mas não para as outras ramificações.

Para ver todos os outros ramos do repo remoto emitir o seguinte comando usando o -a Bandeira que mostra todos os ramos locais e remotos.

$ git ramo -a

Depois de verificar uma filial remota, ele será baixado para o seu repositório local e você poderá continuar trabalhando nela localmente até que você queira empurrar as alterações que fez na filial de volta ao servidor.

Conclusão

Depois de trabalhar com os exemplos acima, encorajo você a continuar brincando com galhos e tags até trabalhar com eles começar a se sentir intuitivo para você. Se você não tem acesso a um repositório remoto, onde pode praticar coisas como empurrar galhos, empurrar tags e verificar galhos remotos, encorajo você a criar uma conta Github gratuita e selecionar a opção de criar um repo privado lá.

Na verdade, eu recomendaria isso mesmo se você tiver acesso a outros repositórios remotos. Se você cometer um erro em sua própria conta particular do github enquanto está aprendendo, não há grandes danos causados. Eu recomendaria que você comece a usar o Git de colaboração quando começar a se sentir super confortável com isso.

Depois de seguir este artigo e o tutorial do Git para o guia para iniciantes, agora você deve se sentir confortável instalando o Git, configurando o Git, trabalhando com ramos, o conceito de versão, marcação e uso do Git para trabalhar com repositórios locais e remotos. Agora você tem o conhecimento prático para levar o poder e a eficiência do Git ainda mais como um sistema de controle de revisão distribuído. Tudo o que você estiver trabalhando, espero que essas informações mudem a maneira como você pensa sobre o seu fluxo de trabalho para melhor.

Tutoriais do Linux relacionados:

  • Tutorial Git para iniciantes
  • Mint 20: Melhor que o Ubuntu e o Microsoft Windows?
  • Como reverter as atualizações do Pacman no Arch Linux
  • Tutorial introdutório para Git no Linux
  • Lista das melhores ferramentas Kali Linux para testes de penetração e…
  • Manjaro Linux vs Arch Linux
  • Sistema Linux Hung? Como escapar para a linha de comando e…
  • Git: renomear ramo
  • Como atualizar os pacotes do Ubuntu no Ubuntu 22.04 Jammy…
  • Lista de aplicativos Git GUI para Linux