Resolvendo Problemas Comuns: Desfazendo Mudanças e Evitando Conflitos

Resolvendo Problemas Comuns: Desfazendo Mudanças e Evitando Conflitos — aula do módulo Git & GitHub na Prática, na trilha Setup Essencial & Terminal…

Leitura de aproximadamente 4 minutos.

Módulo: Git & GitHub na Prática · Curso: Setup Essencial & Terminal Descomplicado · Formação: Formação Nível Zero: Ferramentas Essenciais e Gratuitas de IA e Código

Resolvendo Problemas Comuns: Desfazendo Mudanças e Evitando Conflitos

O que você vai aprender

1. O Princípio de Segurança do Git

A primeira regra ao trabalhar com o Git é lembrar que ele foi desenhado especificamente para proteger o seu trabalho. Desde que você tenha realizado um commit no seu repositório local, é quase impossível perder código por acidente.

Quando o Git exibe um texto em vermelho ou uma mensagem de recusa de comando, ele não está travado: ele está avisando que detectou uma divergência e está esperando a sua decisão para evitar que um arquivo seja sobrescrito indevidamente.


+-------------------------------------------------------------------------------+
|                       ÁRVORE DE DECISÃO: DESFAZENDO MODIFICAÇÕES              |
+-------------------------------------------------------------------------------+
|                                                                               |
|   Você fez uma modificação no arquivo e quer voltar ao estado anterior:       |
|                                                                               |
|   1. O arquivo ainda NÃO foi adicionado com "git add"?                        |
|      └── Comando: "git restore nome-do-arquivo.txt"                           |
|          (Restaura o arquivo exatamente como estava no último commit)         |
|                                                                               |
|   2. O arquivo JÁ FOI adicionado para a Staging Area (verde no git status)?   |
|      └── Comando: "git restore --staged nome-do-arquivo.txt"                  |
|          (Tira o arquivo da bancada sem perder o que você digitou)            |
|                                                                               |
|   3. Você quer inspecionar o que mudou linha por linha antes de decidir?      |
|      └── Comando: "git diff"                                                  |
|                                                                               |
+-------------------------------------------------------------------------------+

2. Inspecionando e Desfazendo Alterações Locais

Sempre que você estiver na dúvida sobre o estado do seu projeto, utilize dois comandos de diagnóstico:

Exemplos práticos de reversão segura:

Se você editou o arquivo app.js, o código parou de funcionar e você deseja descartar todas as alterações recentes voltando ao último commit estável:


git restore app.js

Se você já executou git add ., mas percebeu que incluiu um arquivo temporário por engano:


git restore --staged arquivo-temporario.txt

3. O Arquivo .gitignore: Protegendo Segredos e Desempenho

Em qualquer projeto de desenvolvimento moderno, existem arquivos e pastas que nunca devem ser gravados no Git, como:

1. Arquivos com senhas e chaves de API (por exemplo: .env). 2. Pastas pesadas de bibliotecas e dependências (como node_modules/ no Node.js ou .venv/ no Python). 3. Arquivos temporários do sistema operacional (como .DS_Store no macOS ou Thumbs.db no Windows).

Para instruir o Git a ignorar automaticamente esses arquivos, basta criar um arquivo de texto puro chamado .gitignore na raiz do seu projeto.

Exemplo de um arquivo .gitignore padrão:


# Dependências e bibliotecas externas (são reinstaladas via npm/pip)
node_modules/
.venv/
__pycache__/

# Segredos, senhas e chaves de API privadas
.env
.env.local
*.pem
*.key

# Logs e arquivos temporários
*.log
dist/
.DS_Store

4. Evitando Conflitos de Sincronização

Um conflito de merge ocorre quando duas pessoas (ou você mesmo em dois computadores diferentes) alteram exatamente a mesma linha do mesmo arquivo e tentam enviar para o GitHub.

A regra de ouro para evitar conflitos:

Sempre execute git pull origin main no início da sua sessão de trabalho antes de começar a codificar. Se você mantiver seu repositório local sempre atualizado com a nuvem, a probabilidade de encontrar conflitos na hora do git push é praticamente zero.

5. Armadilhas Comuns e Como Evitar

[!WARNING]
Nunca use o comando git push --force sem orientação expressa: O parâmetro --force força o GitHub a sobrescrever o histórico remoto com o que está no seu computador pessoal, podendo apagar commits legítimos de outros colaboradores ou versões estáveis anteriores. Se um git push for rejeitado, a solução correta é rodar git pull, sincronizar as diferenças locais e tentar o envio novamente.

Exercício Prático

Pratique a inspeção, o uso do .gitignore e a restauração de arquivos no seu repositório de testes:

1. Entre no seu repositório local e crie um arquivo de segredos:


   cd ~/meu-primeiro-repo
   echo "CHAVE_SECRETA_API=123456abcdef" > .env
   git status

(Observe que o arquivo .env aparece listado como não rastreado).

2. Crie o arquivo .gitignore para proteger o segredo:


   echo ".env" > .gitignore
   git status

(Note que o arquivo .env sumiu da lista do Git! Apenas o .gitignore aparece para ser commitado).

3. Comite o arquivo de regras de proteção:


   git add .gitignore
   git commit -m "chore: configurar regras de seguranca no gitignore"

4. Teste a restauração de um arquivo modificado:


   echo "Texto temporário com erro" >> README.md
   git status
   git diff
   git restore README.md
   git status

(O comando git restore removeu a alteração indesejada e o README.md voltou ao estado perfeito original).

Outras aulas do módulo