Desfazendo alterações no GitHub! Introdução a reset, revert e checkout

Nos artigos anteriores, aprendemos a usar `git add` e `git commit` para registrar as alterações nos arquivos. No entanto, no desenvolvimento, erros acontecem. É muito comum pensar: "Ops, commitei o arquivo errado!" ou "Quero voltar para a versão anterior...".

A força do Git está em ter funcionalidades para desfazer esses erros de operação de forma segura e fácil. Neste artigo, explicaremos de maneira simples as diferenças entre os três principais comandos para "desfazer" alterações: `git checkout`, `git reset`, e `git revert`, bem como seus usos específicos em diferentes situações. Depois de dominar isso, você não precisará mais temer os erros de operação!

Os 3 comandos para "desfazer": qual usar e quando?

O Git tem vários comandos para reverter alterações, o que pode confundir os iniciantes. Primeiro, vamos organizar de forma simples o papel e o uso de cada um.

• git checkout: Use quando quiser reverter alterações no seu diretório de trabalho sem ter feito commit. É ideal para situações como: "No final, não quero nenhuma dessas alterações neste arquivo!".
• git reset: Use para cancelar um commit no repositório local que você ainda não enviou com push. É um comando poderoso que faz um commit "como se nunca tivesse existido", mas como reescreve a história, não deve ser usado em repositórios remotos já compartilhados.
• git revert: Use para desfazer um commit que já foi enviado com push e é público. Em vez de apagar o commit, ele cria um "novo commit que anula as alterações do commit especificado". É uma forma segura de corrigir o histórico, tornando-se um comando essencial no desenvolvimento em equipe.

Para se ter uma ideia, a diferença é que o `reset` é como "voltar no tempo com uma máquina do tempo e apagar o futuro (o commit)", enquanto o `revert` é como "publicar um novo artigo para corrigir um erro do passado".

Na prática! Procedimentos para "desfazer" conforme a situação

Agora, vamos ver como usar cada comando em cenários específicos.

Caso 1: Descartar alterações em andamento sem fazer commit (`checkout`)

Este é o caso em que você editou um arquivo, mas decidiu que "no final, quero descartar todas essas alterações". É a maneira mais simples de reverter alterações antes de prepará-las para o commit (staging).

Primeiro, modifique um arquivo para praticar. Em seguida, ao verificar com `git status`, o arquivo aparecerá como "modified". Para descartar essa alteração, execute o seguinte comando.

git checkout -- [nome_do_arquivo]

Por exemplo, se você quiser desfazer as alterações em `index.html`, seria assim:

git checkout -- index.html

Ao executar este comando, o arquivo especificado voltará completamente ao estado do último commit. Atenção: as alterações eliminadas com esta operação não podem ser recuperadas!

Caso 2: Cancelar o último commit (antes de fazer push) (`reset`)

Este é o caso para desfazer um erro local quando você pensa: "Commitei, mas foi um erro!", e ainda não o compartilhou com ninguém (não fez push). O `reset` tem várias opções, mas aqui apresentamos as mais comuns.

Primeiro, verifique o histórico de commits com `git log --oneline` para se certificar de que o commit que você quer desfazer é o último.

git log --oneline

Opção 1: --soft (Cancela apenas o commit, mantém as alterações)
Use quando quiser cancelar apenas o último commit, mas manter as alterações desse commit na área de preparação (staging area). É útil para quando "você errou na mensagem do commit".

git reset --soft HEAD^

Opção 2: --mixed (Cancela o commit e o staging)
Use quando quiser cancelar o último commit e devolver as alterações ao diretório de trabalho. É o comportamento padrão do comando `reset`. É útil para quando "você se esqueceu de adicionar um arquivo", permitindo resetar e depois fazer `add` e `commit` novamente.

git reset --mixed HEAD^

Opção 3: --hard (Remove completamente o commit e as alterações)
Use quando quiser apagar completamente e sem deixar vestígios o último commit e suas alterações. É um comando perigoso, pois as alterações nos arquivos não poderão ser recuperadas, então use-o com muito cuidado.

git reset --hard HEAD^

HEAD^ refere-se ao "commit anterior". Se quiser retroceder dois commits, pode especificar `HEAD^^` ou `HEAD~2`.

Caso 3: Desfazer um commit que já foi enviado com push (`revert`)

Se você está trabalhando em equipe, apagar um commit que já foi enviado com `reset` pode criar conflitos com o histórico de outras pessoas e causar uma grande confusão. Por isso, para desfazer um commit que já é público, sempre use `revert`.

`revert` cria automaticamente um "novo commit" que anula todas as alterações do commit que você especificar. É um método seguro que não apaga a história, mas adiciona uma nova história que corrige o erro.

Primeiro, use `git log` para encontrar o ID (hash) do commit que você quer desfazer.

git log

Copie o hash do commit que quer desfazer (ex: `1a2b3c4d`) e execute o seguinte comando.

git revert 1a2b3c4d

Ao executá-lo, abrir-se-á uma tela de edição da mensagem do commit. Se estiver de acordo com a mensagem padrão, simplesmente guarde-a e feche. Com isto, um "commit de reversão" será criado. Finalmente, faça `push` desse commit para que a correção se reflita também no repositório remoto.

【Copia e cola para rodar】Exemplo de HTML para praticar

Para testar as operações do Git, é útil ter um arquivo ao qual você possa realmente fazer alterações. Salve o seguinte código HTML com um nome como `practice.html` e tente usar `add`, `commit`, `checkout`, `reset`, etc., com este arquivo.

<!DOCTYPE html>
<html lang="pt">
<head>
    <meta charset="UTF-8">
    <title>Página de Prática de Git</title>
    <style>
        body { font-family: sans-serif; text-align: center; margin-top: 50px; }
        .box { width: 200px; height: 200px; margin: 20px auto; border: 2px solid #333; display: flex; justify-content: center; align-items: center; font-size: 1.5rem; }
        .box.red { background-color: #ffcccc; }
        .box.blue { background-color: #cceeff; }
        button { padding: 10px 20px; font-size: 1rem; cursor: pointer; }
    </style>
</head>
<body>
    <h1>Praticando Operações do Git</h1>
    <div id="colorBox" class="box">Texto aqui</div>
    <button id="changeColorBtn">Mudar Cor</button>
    <script>
        const colorBox = document.getElementById('colorBox');
        const changeColorBtn = document.getElementById('changeColorBtn');
        changeColorBtn.addEventListener('click', () => {
            if (colorBox.classList.contains('red')) {
                colorBox.classList.remove('red');
                colorBox.classList.add('blue');
                colorBox.textContent = 'Alterado para Azul!';
            } else {
                colorBox.classList.remove('blue');
                colorBox.classList.add('red');
                colorBox.textContent = 'Alterado para Vermelho!';
            }
        });
    </script>
</body>
</html>

Conclusão: Escolha o comando ideal para cada situação

Para terminar, vamos resumir de forma simples o uso dos três comandos para desfazer alterações.

• Descartar alterações sem commit → git checkout -- [nome_do_arquivo]
• Cancelar um commit local → git reset [opção] HEAD^
• Anular um commit já público → git revert [commit_id]

Se você dominar estes três, não precisará mais ter medo de cometer erros de operação no Git. Sinta-se à vontade para escrever código e fazer commits com confiança!