Git na prática: branches, merge e como não perder trabalho

No post Introdução ao Git, vimos o que é o Git, para que ele serve e os primeiros comandos para criar um repositório e fazer commits. Agora é hora de dar o próximo passo: trabalhar com branches.

Branches são o que tornam o Git tão poderoso no dia a dia. Com elas, você testa ideias, desenvolve funcionalidades e corrige bugs sem bagunçar a versão que está funcionando. Neste post, vamos ver como criar branches, juntar o trabalho com merge, resolver conflitos e, principalmente, como não perder nada pelo caminho.

O que é uma branch

Uma branch (ramo, em português) é uma linha independente de desenvolvimento. Pense no seu projeto como uma linha do tempo de commits: quando você cria uma branch, abre um caminho paralelo a partir daquele ponto. O que você fizer nele não afeta a branch principal até que você decida juntar os dois.

Todo repositório começa com uma branch principal, normalmente chamada main (em projetos mais antigos, master). A boa prática é manter a main sempre estável e fazer cada mudança em uma branch própria.

Criando e trocando de branch

Para ver as branches do repositório e saber em qual você está:

git branch

A branch atual aparece marcada com um asterisco. Para criar uma nova branch e já mudar para ela:

git switch -c nova-pagina-contato

O comando git switch existe desde a versão 2.23 do Git. Em tutoriais mais antigos, você vai encontrar o equivalente git checkout -b nova-pagina-contato, que faz a mesma coisa.

Para voltar a uma branch que já existe, basta tirar o -c:

git switch main

Trabalhando na branch

Dentro da branch, o fluxo é o mesmo que você já conhece: editar os arquivos, adicionar e fazer commit.

git add .
git commit -m "Cria a página de contato"

Esses commits ficam só na branch nova-pagina-contato. Se você voltar para a main, vai ver os arquivos como estavam antes: o Git troca o conteúdo da pasta automaticamente.

Juntando o trabalho com merge

Quando a funcionalidade estiver pronta, é hora de trazê-la para a branch principal. Primeiro, vá para a branch que vai receber as mudanças; depois, faça o merge:

git switch main
git merge nova-pagina-contato

Se a main não recebeu nenhum commit novo desde que a branch foi criada, o Git apenas avança a main até o último commit da branch (o chamado fast-forward). Se as duas branches tiveram commits, o Git cria um commit de merge que une os dois históricos.

Depois do merge, a branch pode ser apagada:

git branch -d nova-pagina-contato

O -d só apaga a branch se o trabalho dela já foi integrado, então você não corre o risco de perder commits por engano.

Conflitos de merge: o que são e como resolver

Um conflito acontece quando as duas branches alteraram a mesma parte de um arquivo e o Git não sabe qual versão manter. Ele interrompe o merge e marca o trecho no arquivo assim:

<<<<<<< HEAD
<h1>Fale conosco</h1>
=======
<h1>Entre em contato</h1>
>>>>>>> nova-pagina-contato

O trecho entre <<<<<<< HEAD e ======= é a versão da branch atual; o trecho seguinte, até >>>>>>>, é a versão da branch que está chegando. Para resolver:

1. Abra o arquivo e escolha uma das versões, ou combine as duas.

2. Apague as linhas de marcação (<<<<<<<, ======= e >>>>>>>).

3. Salve o arquivo e marque o conflito como resolvido com git add.

4. Conclua o merge com git commit.

git add index.html
git commit

Se preferir desistir e voltar ao estado de antes do merge, use git merge --abort. Editores como o VS Code também mostram os conflitos com botões para aceitar uma versão ou a outra, o que facilita bastante.

Como não perder trabalho

Medo de perder código é comum no começo. A boa notícia é que o Git guarda quase tudo, e alguns comandos ajudam muito.

Guarde mudanças temporariamente com stash

Precisa trocar de branch, mas ainda não quer fazer commit do que está pela metade? O git stash guarda as alterações numa espécie de gaveta e deixa a pasta limpa:

git stash
git switch main
# ... resolve o que precisava ...
git switch nova-pagina-contato
git stash pop

git stash pop devolve as alterações e as tira da gaveta. Para ver o que está guardado, use git stash list.

Desfaça alterações com cuidado

Para descartar as mudanças de um arquivo que ainda não foram adicionadas com git add, use:

git restore index.html

Atenção: essas mudanças não estavam salvas em nenhum commit, então não há como recuperá-las depois.

Recupere commits com reflog

Apagou uma branch sem querer ou desfez um commit que não devia? O git reflog mostra tudo o que aconteceu no repositório, inclusive commits que não aparecem mais no histórico:

git reflog
git switch -c recuperada a1b2c3d

Basta encontrar o identificador do commit na lista (no exemplo, a1b2c3d) e criar uma branch a partir dele.

Faça commits pequenos e envie para o remoto

O melhor seguro é fazer commits com frequência e enviar o trabalho para um repositório remoto, como o GitHub:

git push -u origin nova-pagina-contato

Assim, mesmo que o seu computador tenha algum problema, o código está guardado em outro lugar.

Resumo do fluxo

1. Atualize a main com git pull e crie uma branch para a tarefa: git switch -c minha-tarefa.

2. Trabalhe e faça commits pequenos, com mensagens claras.

3. Volte para a main e faça o merge: git merge minha-tarefa.

4. Resolva os conflitos, se aparecerem.

5. Apague a branch: git branch -d minha-tarefa.

Próximos passos

Com branches e merge, você já trabalha como a maioria dos times profissionais. O próximo passo é levar esse fluxo para o GitHub, onde as branches viram pull requests: uma forma de revisar e discutir o código antes de juntá-lo à main. Esse é o assunto de um próximo post.