Introdução
Básico
Branches
Merge/Rebase
Avançado
GitHub
CI/CD

Tutorial Git/GitHub/VS Code: Gerenciamento de Branches via Terminal

Este tutorial foca no uso do terminal (integrado no VS Code ou externo) para gerenciar branches no Git e GitHub, cobrindo criação, commits essenciais, correção de erros e merge.

Contexto: Usuário do VS Code com projeto Git/GitHub buscando aprofundar o uso do terminal.


Pré-requisitos

  1. Git Instalado: Verifique com git --version.
  2. VS Code Instalado: Com acesso ao terminal integrado (Ctrl+` ou Cmd+`).
  3. Projeto Existente: Pasta com git init já executado e, idealmente, conectado a um repositório remoto (git remote add origin <URL>).
  4. Branch Principal: Assumimos master ou main. Adapte os comandos se necessário.

Commits: Salvando Alterações

Objetivo: Entender como fazer commits efetivos e boas práticas.

Anatomia de um Bom Commit:

Fluxo Básico de Commit:

git status # Verificar alterações
git diff # Ver mudanças detalhadas
git add . # Adicionar todas as alterações
git commit -m "feat: adiciona funcionalidade de login"

Boas Práticas de Commit:

  1. Verifique Antes: Use git status e git diff
  2. Commits Frequentes: Faça commits pequenos e frequentes
  3. Mensagens Padronizadas:
    # Exemplos de boas mensagens de commit:
    feat(auth): implementa autenticação via Google
    fix(login): corrige validação de senha
    docs(readme): atualiza instruções de instalação
    style(css): ajusta layout responsivo
    refactor(api): melhora performance das consultas
    test(unit): adiciona testes para módulo de pagamento
    chore(deps): atualiza dependências

Nova Branch: Criando e Gerenciando

Objetivo: Isolar novas funcionalidades ou correções sem afetar a versão estável (master/main).

Boas Práticas de Nomenclatura:

Passos no Terminal do VS Code:

  1. Abra o Terminal: Ctrl+` ou Cmd+`.
  2. Verifique e Vá para a Branch Principal:
    git status # Verifica a branch atual
    # Se não estiver na principal, mude:
    git checkout master # ou git checkout main
  3. (Recomendado) Atualize a Branch Principal:
    git pull origin master # ou git pull origin main
  4. Crie e Mude para a Nova Branch: (Ex: feature/login-screen)
    # Opção 1: Tradicional
    git checkout -b feature/login-screen
    # Opção 2: Moderna
    git switch -c feature/login-screen

    Confirmação: O terminal indicará a mudança.

  5. (Opcional) Publique a Nova Branch no GitHub: (Necessário para colaborar/backup)
    git push -u origin feature/login-screen

    O -u vincula a branch local à remota para futuros git push.

Agora você está na nova branch (feature/login-screen). É hora de começar a trabalhar e salvar seu progresso.


Lidando com Erros no Git

Cenário: Você fez commits na branch alternativa (feature/login-screen), mas o resultado não foi bom e precisa reverter ou descartar.

Opção A: Descartar a Branch Inteira (Local e Remota)

Use se a branch inteira está comprometida.

  1. Salve Código Útil (se houver): Copie manualmente trechos importantes para fora do projeto.
  2. Mude para a Branch Principal:
    git checkout master # ou git checkout main
  3. Delete a Branch Localmente (Forçado):
    git branch -D feature/login-screen

    -D (maiúsculo) força a deleção mesmo sem merge.

  4. Delete a Branch Remotamente (no GitHub): (Se já publicou)
    git push origin --delete feature/login-screen

Resultado: A branch feature/login-screen é removida local e remotamente.

Opção B: Desfazer Commits na Branch Atual (Reverter para um Estado Anterior)

Use se quer manter a branch, mas voltar a um commit específico.

⚠️ CUIDADO: Isso reescreve o histórico. Perigoso se a branch for compartilhada. Prefira git revert em branches colaborativas.

  1. Identifique o Commit para Onde Voltar:
    git log --oneline --graph
    # Anote o hash do commit desejado (ex: a1b2c3d)
  2. Resete a Branch para Aquele Commit (Descartando Posteriores):
    # Substitua 'a1b2c3d' pelo hash real
    git reset --hard a1b2c3d

    reset --hard descarta permanentemente alterações e commits após o hash especificado.

    Use git reflog para encontrar hashes anteriores se precisar desfazer o reset.

  3. Atualize a Branch Remota (Com Cuidado): (Se já publicou os commits ruins)
    # Use --force-with-lease (mais seguro que --force)
    git push --force-with-lease origin feature/login-screen

    Isso força o histórico remoto a espelhar o seu local reescrito.


Mesclando Branches

Cenário: O trabalho na feature/login-screen está concluído, testado e pronto para ser incorporado à master/main.

Passos no Terminal (Merge Direto):

  1. Finalize a Feature Branch:
  2. Mude para a Branch Destino:
    git checkout master # ou git checkout main
  3. Atualize a Branch Destino: CRUCIAL para evitar conflitos desnecessários.
    git pull origin master # ou git pull origin main
  4. Mescle (Merge) a Feature Branch:
    git merge feature/login-screen
  5. Envie a Master/Main Atualizada para o GitHub:
    git push origin master # ou git push origin main
  6. (Boa Prática) Delete a Feature Branch (Já Mesclada):

Alternativa: Fluxo com Pull Request (GitHub) - Recomendado

Adiciona revisão e é padrão em equipes.

  1. Após garantir que a branch feature/login-screen está completa e no GitHub (git push -u origin feature/login-screen), vá para a página do seu repositório no GitHub.
  2. Clique em "Compare & pull request" para a branch recém-enviada.
  3. Preencha a descrição do Pull Request (PR) e crie-o.
  4. Revisão: Você ou um colega revisa as alterações na interface do GitHub.
  5. Merge: Se aprovado, clique em "Merge pull request" no GitHub. O merge acontece no servidor remoto.
  6. (Opcional) Delete a branch remota pelo botão do GitHub após o merge.
  7. Atualize Localmente:
    # Volte para a branch principal
    git checkout master # ou git checkout main
    # Traga as alterações (incluindo o merge) do remoto
    git pull origin master # ou git pull origin main
  8. Delete a Branch Local:
    git branch -d feature/login-screen

Atalhos úteis do VS Code

Ctrl + ` Abrir/Fechar Terminal
Ctrl + Shift + G Abrir Git

Perguntas Frequentes (FAQ)

Como desfazer o último commit?

Para desfazer o último commit mantendo as alterações:

git reset --soft HEAD~1

Para desfazer e descartar as alterações:

git reset --hard HEAD~1
Como resolver conflitos no merge?
  1. Abra os arquivos com conflito no VS Code
  2. Procure por marcadores <<<<<<<
  3. Escolha qual versão manter ou combine-as
  4. Remova os marcadores de conflito
  5. Salve o arquivo
  6. Execute: git add . seguido de git commit
Como voltar para uma versão anterior do código?

1. Para visualizar o histórico:

git log --oneline

2. Para voltar a um commit específico:

git checkout [hash-do-commit]
Como criar uma nova branch e mudar para ela?

Use o comando:

git checkout -b nome-da-branch

Ou na versão mais moderna:

git switch -c nome-da-branch

Git Stash: Salvando Trabalho Temporário

Objetivo: Salvar alterações temporárias sem fazer commit quando precisar mudar de branch.

Comandos Principais:

git stash save "mensagem descritiva" # Salva alterações
git stash list # Lista stashes
git stash pop # Aplica e remove o último stash
git stash apply # Aplica sem remover

Git Flow: Estratégia de Branches

Conceito: Metodologia para organizar branches em projetos maiores.

Estrutura Principal:


Exercícios Práticos

Exercício 1: Criando e Mesclando Branches

Objetivo: Praticar criação e merge de branches

  1. Crie uma nova branch chamada "feature/exercicio-1"
  2. Adicione um arquivo README.md com seu nome
  3. Faça commit das alterações
  4. Volte para a branch principal e faça o merge

Exercício 2: Resolvendo Conflitos

Objetivo: Praticar resolução de conflitos

  1. Crie duas branches: "feature/a" e "feature/b"
  2. Em cada uma, modifique a mesma linha do README.md
  3. Tente fazer o merge e resolva o conflito

Recursos Adicionais


Boas Práticas de Segurança

⚠️ Nunca compartilhe ou comite:

Dicas de Segurança:



Conclusão

Dominar o fluxo de status -> add -> commit é fundamental para usar o Git eficientemente. Combinado com o gerenciamento de branches, permite um desenvolvimento mais organizado e seguro. Pratique esses comandos no terminal para ganhar fluência.