Ramo do Git: Um guia para criar, gerenciar e mesclar ramificações

Se você já trabalhou em um projeto de codificação em grupo, sabe como as coisas podem sair do controle rapidamente quando várias pessoas tentam atualizar os arquivos duplicados simultaneamente. Surgem conflitos, bugs se infiltram e o progresso é interrompido. É aí que entram as ramificações do Git, não como um truque avançado, mas como a base de um desenvolvimento limpo e paralelo.

No Git, a ramificação não é apenas incentivada; ela é esperada. Seja experimentando um novo recurso, corrigindo um bug ou revisando o código de outra pessoa, as ramificações permitem que você trabalhe sem pisar nos pés de ninguém. Eles permitem que você quebre as coisas, faça iterações e integre suas alterações de forma organizada à base de código principal.

Este guia orienta você sobre os fundamentos da ramificação no Git. Começaremos com git branch e git checkout e, em seguida, examinaremos mais de perto como as ramificações são criadas, gerenciadas, mescladas e excluídas. Também discutiremos as práticas recomendadas para que você possa manter seu fluxo de trabalho livre de conflitos. Espero que, ao final deste guia, você tenha uma compreensão maior do que a memorização de comandos: Você entenderá um pouco mais sobre o fluxo de trabalho. Se tudo isso for interessante para você e você quiser continuar praticando, nosso curso Introdução aos conceitos do GitHub é um ótimo lugar para começar.

Entendendo as ramificações do Git

Agora que já preparamos o cenário, vamos explicar o que é uma ramificação do Git. Em sua essência, uma ramificação do Git não é uma pasta separada ou uma cópia completa da sua base de código; é apenas um ponteiro leve para um commit específico. Esse é um dos motivos pelos quais o Git se destaca em relação aos sistemas de controle de versão mais antigos: a ramificação é rápida, barata e central para os fluxos de trabalho diários.

Pense em um ramo como uma linha do tempo. Ao criar uma nova ramificação, você basicamente diz: "Vamos explorar um novo caminho a partir daqui". Todas as suas alterações permanecem nesse caminho até que você decida mesclá-las de volta à linha principal ou não. Essa flexibilidade torna incrivelmente fácil testar ideias, criar recursos isoladamente e colaborar com outras pessoas sem interferir no código estável.

O Git mantém o controle da sua posição atual no projeto usando uma referência especial chamada HEAD. Quando você muda de ramo, HEAD aponta para a ponta do novo ramo. Esse detalhe dos bastidores permite que o Git alterne contextos tão rapidamente e é também o que faz com que comandos como git checkout e git switch pareçam tão perfeitos quando você entende o que está acontecendo nos bastidores.

Ao entender como as ramificações do Git funcionam, você terá o poder de organizar seu fluxo de trabalho de desenvolvimento com clareza e confiança. Se você estiver acompanhando e quiser testar esses conceitos, o curso Git Intermediário da DataCamp aborda a ramificação com muita prática guiada.

Listagem e visualização de ramificações do Git

Então, você criou filiais e começou a usá-las, mas como manter o controle de tudo? Felizmente, o Git fornece ferramentas simples, mas poderosas, para listar, classificar e filtrar ramificações para que você nunca perca de vista o seu fluxo de trabalho.

Verificando o ramo atual

Para começar, vamos verificar quais ramificações existem em seu repositório local e identificar em qual delas você está atualmente.

git branch

Esse comando lista todas as filiais locais que você possui. Você verá um asterisco ( *) ao lado do ramo atual. Para um visual ainda mais direcionado, experimente:

git branch --show-current

Isso retorna apenas o nome da ramificação em que você está trabalhando de forma limpa e agradável.

Você também quer ver as filiais remotas? Use:

git branch -r

E se você quiser visualizar as filiais locais e remotas ao mesmo tempo:

git branch -a

Isso dá a você uma visão completa da estrutura de ramificação do seu projeto, o que é especialmente útil ao colaborar com outras pessoas em plataformas como o GitHub. 

Classificação e filtragem de ramificações

À medida que seu projeto cresce, a lista de ramificações também cresce. A classificação e a filtragem ajudam você a gerenciar essa lista com eficiência. Para classificar as ramificações pela data de confirmação mais recente, use:

git branch --sort=-committerdate

Você também pode classificar por outros critérios, como nome do autor, data de criação ou configuração upstream. Aqui está um recurso útil para filtrar ramificações que contêm um commit específico:

git branch --contains <commit>

Isso mostra a você quais ramificações já incluíram um determinado commit, o que ajuda a verificar se uma correção de bug ou recurso foi mesclado a elas. Por outro lado, o comando abaixo mostra a você quais ramificações ainda não pegaram esse commit:

git branch --no-contains <commit>

O gerenciamento eficaz de filiais envolve criá-las, bem como garantir visibilidade e controle. Esses comandos ajudam a manter seu desenvolvimento limpo, organizado e eficiente.

Você quer saber como isso se relaciona com a colaboração? O curso Foundations of Git fornece uma excelente base e abrange fluxos de trabalho do mundo real que você usará repetidamente.

Criação de uma nova ramificação do Git

Agora que você já sabe como listar e alternar entre as ramificações, vamos ver como criá-las. A ramificação é uma parte essencial do fluxo de trabalho do Git e, felizmente, a criação de novas ramificações é simples, quer você esteja configurando uma ramificação de recurso, um hotfix ou experimentando algo totalmente novo.

Criação de uma filial sem mudança

Às vezes, você deseja criar uma ramificação sem entrar nela imediatamente. Isso é útil quando você está preparando várias ramificações de uma vez ou quando está configurando fluxos de trabalho para outras pessoas.

git branch new-feature

Esse comando cria um ramo chamado new-feature, mas você ainda estará no ramo atual. Você pode mudar para ele mais tarde, quando estiver pronto para trabalhar nele.

Criar e mudar para uma filial simultaneamente

Se você estiver entrando diretamente no desenvolvimento, poderá criar e mudar para o novo ramo de uma só vez. Em versões mais antigas do Git, você usaria:

git checkout -b new-feature

No entanto, no Git moderno, a abordagem mais transparente e intuitiva é a seguinte:

git switch -c new-feature

Isso não apenas cria o ramo, mas também o verifica imediatamente, para que você esteja pronto para começar a trabalhar.

Configuração de ramificações upstream

Quando você estiver trabalhando com repositórios remotos, muitas vezes desejará que o seu ramo local rastreie um ramo remoto. Isso simplifica o envio e a retirada de atualizações. Para criar uma ramificação que programa uma ramificação remota desde o início, use:

git branch --track new-feature origin/new-feature

Se você já tiver criado a ramificação e quiser definir ou alterar o upstream, esse comando fará isso:

git branch --set-upstream-to=origin/new-feature

Essa configuração garante que a filial local saiba de qual filial remota você deve fazer pull ou push, mantendo o fluxo de trabalho tranquilo e conectado.

Alternando entre ramificações do Git

Depois de criar algumas ramificações, muitas vezes você precisará alternar entre elas, seja voltando para main para mesclar uma correção ou mudando para uma ramificação de recurso para continuar a codificação. O Git facilita esse processo e, como a maioria das coisas relacionadas ao Git, há mais de uma maneira de fazer isso.

Usando o git checkout

Durante muito tempo, o git checkout foi o comando de referência para você mudar de ramo:

git checkout feature-login

Esse comando muda seu diretório de trabalho para a ramificação feature-login, atualizando todos os seus arquivos para refletir o instantâneo dessa ramificação. Ele é confiável e ainda é amplamente utilizado. Mas o problema é o seguinte: git checkout faz muitas coisas. Ele é usado para alternar ramificações, restaurar arquivos e até mesmo verificar commits. Isso pode ser confuso, especialmente se você estiver começando.

Usando o git switch

Para tornar as coisas mais intuitivas, o Git introduziu o site the git switch na versão 2.23:

git switch feature-login

Isso faz exatamente o que você espera: alterna as ramificações. Ele não toca na sua árvore de trabalho nem redefine seus arquivos, a menos que você o solicite. É mais simples, mais seguro e mais fácil de ensinar e lembrar.

Então, quando você deve usar qual?

• Use o site git switch para alternar entre as ramificações, pois ele é claro e foi criado para esse fim.
• Use git checkout se você precisar restaurar arquivos ou verificar um commit específico.

Mesclando ramificações do Git

Então, você está trabalhando em um recurso em uma ramificação separada. Agora chega o momento da verdade: combinar suas alterações na ramificação principal. No Git, esse processo é chamado de merging. Dependendo do histórico de suas filiais, há várias maneiras de abordá-las.

Fusão de avanço rápido

Digamos que o seu feature branch tenha começado a partir do the main e, enquanto você estava trabalhando nele, ninguém mais tocou no main. Nesse caso, o Git não precisa pensar muito. Ele simplesmente move o ponteiro main para o último commit em feature-branch.

git checkout main
git merge feature-branch

Nenhum novo commit é criado - o Git avança rapidamente main. Limpo, simples e perfeito para projetos individuais ou ramificações de curta duração.

Mesclagem de três vias

As coisas ficam mais interessantes quando os dois ramos progridem independentemente um do outro. Seu colega de equipe pode ter adicionado algumas alterações ao principal enquanto você estava codificando em the feature branch. Agora, o Git precisa examinar três snapshots: o ancestral comum, o seu ramo e o ramo de destino.

git checkout main
git merge feature-branch

Nesse caso, o Git cria um novo commit de mesclagem para combinar as duas ramificações. Se houver conflitos, digamos que você e seu colega de equipe tenham alterado a mesma linha no mesmo arquivo, o Git solicitará que você os resolva manualmente. Você editará o arquivo, marcará como resolvido e confirmará a mesclagem.

git add .
git commit

Se isso parecer um pouco intimidador, você pode consultar nosso tutorial Git Merge: A Comprehensive Guide with Examples é um excelente passo a passo que aborda todos os aspectos essenciais, inclusive o tratamento de conflitos com elegância.

Rebase em vez de mesclagem

Você não é fã de commits de mesclagem que ficam bagunçando seu histórico? Você não está sozinho. É aí que entra o Git rebase. Em vez de criar um novo commit de mesclagem, o rebase repete as alterações que você fez em cima de outra ramificação, resultando em um histórico mais limpo e linear.

git checkout feature-branch
git rebase main

Então, quando você faz a mesclagem, o Git vê uma linha reta - não há necessidade de um commit de mesclagem. No entanto, use-o com cautela, especialmente ao trabalhar com ramificações compartilhadas. Reescrever o histórico pode ser perigoso se outras pessoas estiverem trabalhando no mesmo código.

Para que você saiba quando é melhor usar o merge em vez do rebase (e como fazer o rebase com segurança), o curso Git intermediário oferece a você orientação prática e prática.

Exclusão de ramificações do Git

Após uma mesclagem bem-sucedida, é uma boa ideia limpar todas as ramificações de que você não precisa mais, tanto local quanto remotamente. Isso mantém o seu espaço de trabalho organizado e o histórico do Git mais fácil de navegar. Vamos explicar como você pode fazer isso sem perder o sono por excluir acidentalmente algo importante.

Exclusão de filiais locais

Quando um branch tiver sido mesclado e seu trabalho estiver concluído, você poderá excluí-lo com segurança do seu repositório local:

git branch -d feature-branch

O sinalizador-d significa "delete" (excluir). O Git verificará se o ramo já foi mesclado para evitar possíveis perdas de dados.

Mas e se você quiser excluir uma ramificação, mesmo que ela tenha sido mesclada? É aí que entra o -D maiúsculo:

git branch -D feature-branch

Isso força a exclusão, mesmo que o Git avise a você que o ramo não foi mesclado. Antes de pressionar Enter, certifique-se de que você não precisa dessas alterações.

Você quer se aprofundar no gerenciamento do seu espaço de trabalho local e das filiais? Confira nosso Git Pull Force: Como substituir uma ramificação local por uma remota tutorial. É um companheiro útil para garantir que você não esteja apenas excluindo, mas também gerenciando as ramificações com segurança.

Exclusão de filiais remotas

A limpeza local é apenas a metade do trabalho. Se o ramo também estiver em um local remoto (como o GitHub), você também deverá removê-lo de lá, especialmente se tiver terminado de usar o recurso ou a correção de bug.

git push origin --delete feature-branch

Esse comando diz ao Git para remover o ramo da origem remote. Ele é limpo e direto, ajudando a evitar que o controle remoto fique cheio de ramificações não utilizadas.

Depois que você excluir as ramificações remotas, também é uma boa ideia limpar as referências de rastreamento locais.

git fetch -p

O -p significa "prune" (ameixa). Ele remove todas as ramificações obsoletas de rastreamento remoto que não existem mais no servidor.

Para obter mais hábitos úteis de higiene do Git, o Git Push and Pull Tutorial e o Complete Git Cheat Sheet são referências rápidas perfeitas.

Empurrando e puxando ramificações do Git

Depois que você tiver criado e organizado suas ramificações localmente, a próxima etapa é sincronizá-las com o repositório remoto. Isso é essencial para a colaboração e o backup. Vamos explicar a você como empurrar, puxar e programar as ramificações de forma eficaz.

Empurrando uma nova ramificação para o controle remoto

Você criou um novo recurso localmente e o testou, e agora quer compartilhá-lo com sua equipe ou fazer o backup. Para enviar uma nova ramificação para um repositório remoto (normalmente denominado origin), use:

git push -u origin new-feature

O sinalizador -u (abreviação de --set-upstream) diz ao Git para lembrar o ramo remoto para futuros pulls e pushes. Dessa forma, da próxima vez, você pode simplesmente executar git pull ou git push sem especificar o ramo.

Se você estiver se perguntando o que mais acontece nos bastidores durante um push ou pull, nosso tutorial Git Push and Pull explica com exemplos que você pode seguir.

Extração de alterações de uma ramificação remota

Digamos que outra pessoa tenha enviado atualizações para o mesmo ramo em que você está trabalhando. Você deverá fazer essas alterações para manter a sincronia:

Git pull origin new-feature

Isso obtém os últimos commits do ramo remoto e os mescla com o ramo local. Se você quiser evitar a mesclagem de commits, considere usar o seguinte:

git pull --rebase origin new-feature

Como explica a seção de mesclagem, o --rebase ajuda a manter o histórico de commits limpo.

Programa de rastreamento de uma filial remota

Quando você quiser começar a trabalhar com uma ramificação que já existe no controle remoto, a maneira mais fácil de configurar as coisas é:

git checkout --track origin/feature-xyz

Esse comando verifica a ramificação remota e configura automaticamente o controle, para que você possa fazer futuros pulls e pushes com facilidade.

Problemas comuns e solução de problemas

Mesmo com os melhores fluxos de trabalho, as coisas nem sempre correm bem. Seja um conflito de mesclagem, um ramo excluído acidentalmente ou algumas alterações não confirmadas atrapalhando você, o Git tem ferramentas para ajudá-lo a se recuperar. Vamos examinar alguns dos problemas mais comuns de ramificação e como corrigi-los.

Manipulação de conflitos de mesclagem

Você acabou de tentar mesclar uma ramificação e o Git gerou um conflito de mesclagem. Isso acontece quando duas ramificações alteram a mesma parte de um arquivo de forma diferente, e o Git não consegue decidir qual alteração manter.

Veja como você pode lidar com isso:

git status

Isso informa a você quais arquivos estão em conflito. Então, você pode usar:

git diff

Para ver o que está causando o problema. A partir daí, abra manualmente o(s) arquivo(s) conflitante(s), resolva as diferenças e, em seguida

git add <resolved-file>
git commit

Se você quiser saber mais sobre a mesclagem de fluxos de trabalho e a resolução de conflitos, consulte o Git Merge Tutorial, que fornece um passo a passo completo.

Recuperação de ramificações excluídas

Você excluiu acidentalmente uma ramificação e está sentindo o pânico se instalar? Não se preocupe - ele não está perdido para sempre se você agir rapidamente.

Você pode recuperá-lo usando git reflog, que registra suas posições recentes no HEAD:

git reflog

Encontre o hash do commit antes de você excluir o ramo e recrie-o com:

git checkout -b your-branch-name <commit-hash>

E, sem mais nem menos, sua filial está de volta. Você quer entender melhor como o Git programa essas referências? Nosso Guia do Git Reflog explica isso com exemplos reais.

Armazenamento de alterações antes da troca

Às vezes, você deseja trocar de ramificação, mas tem alterações não confirmadas. O Git não permitirá que você mude se isso puder resultar em perda de trabalho. É aí que entra o git stash.

git stash

E o Git deixará suas alterações de lado temporariamente. Depois de trocar de ramo, você pode trazê-los de volta:

git stash pop

Isso é especialmente útil ao alternar entre recursos ou hotfixes.

Se estiver gerenciando muitas alterações ou limpando o diretório de trabalho, talvez você também se interesse pelo Git Clean: Remover arquivos não rastreados e manter os repositórios organizados.

Estratégias avançadas de ramificação

Até agora, você já viu como criar, alternar e gerenciar ramificações do Git com facilidade. Mas como as equipes usam essas ramificações em projetos do mundo real? A resposta está na escolha da estratégia de ramificação correta - uma estrutura de como e quando usar as ramificações em seu fluxo de trabalho de desenvolvimento. Vamos explorar algumas das abordagens mais populares.

Fluxo de trabalho da ramificação de recursos

O fluxo de trabalho de ramificação de recursos é uma das estratégias mais comuns, especialmente em projetos colaborativos. Veja como isso funciona:

Cada novo recurso recebe sua própria ramificação, criada a partir da ramificação principal (ou develop). Isso permite que os desenvolvedores trabalhem de forma independente sem afetar o código pronto para produção.

git switch -c feature/login-page

Quando o recurso estiver concluído e testado, ele será mesclado novamente no branch principal (ou em um branch de preparação) por meio de uma solicitação pull.

Esse modelo ajuda a isolar o trabalho, torna as revisões de código mais gerenciáveis e evita que você sobrecarregue a ramificação principal com recursos inacabados. Para manter a colaboração remota sem problemas, não se esqueça de empurrar suas ramificações:

git push -u origin feature/login-page

Você precisa de uma atualização sobre como empurrar e puxar galhos? O tutorial Git Push and Pull orienta você em todo o processo.

Fluxo de trabalho do GitFlow

Se você estiver trabalhando em um projeto com lançamentos regulares, o GitFlow pode ser uma boa opção. Esse fluxo de trabalho introduz funções estruturadas para diferentes tipos de filiais:

• mainVocê pode usar o código de produção: sempre contém código pronto para produção.

• develop: ramo de integração para recursos.

• feature/*: ramificações de curta duração para novos recursos.

• release/*: ramificações de pré-produção para testes.

• hotfix/*: As correções rápidas são baseadas no main.

Aqui está um exemplo rápido de como iniciar uma nova ramificação de recurso usando as ferramentas do GitFlow:

git flow feature start payment integration

Essa estratégia adiciona um pouco de complexidade, mas se destaca em equipes maiores em que a estrutura clara e a estabilidade são prioridades. Se você estiver explorando fluxos de trabalho além do GitHub, consulte What GitLab Is: Features, Benefits, and How to Get Started para que você tenha outra visão das práticas estruturadas do Git.

Desenvolvimento baseado em tronco

Você prefere um número mínimo de ramificações e uma entrega rápida? O desenvolvimento baseado em tronco pode ser o seu estilo. Nessa estratégia, todos os desenvolvedores fazem commit em uma única ramificação, geralmente a main, com commits pequenos e frequentes. Em vez de ramificações de recursos de longa duração, essa abordagem incentiva ramificações de curta duração ou commits diretos para a ramificação main.

É rápido e direto, mas requer disciplina, automação de teste sólida e boa comunicação. Esse modelo é padrão em startups e equipes que praticam DevOps ou CI/CD. A escolha de uma estratégia de ramificação depende do tamanho da sua equipe e da cadência de lançamentos, além, é claro, do nível de colaboração.

Conclusão

As ramificações estão no centro do sistema de controle de versão do Git. Eles permitem que os desenvolvedores trabalhem em novos recursos, correções de bugs e experimentos de forma isolada, sem interromper a base de código principal. Essa flexibilidade leva a fluxos de trabalho mais limpos e organizados e a uma melhor colaboração entre as equipes.

Ao fazer commits com frequência, mesclar de forma responsável e manter uma estrutura de ramificação limpa, você reduz o risco de conflitos e torna sua base de código mais fácil de navegar e manter. Sem dúvida, dominar as ramificações do Git ajuda você a fornecer um software melhor ao longo do tempo.