Git Reflog: Entendendo e usando os registros de referência no Git

Não há nada mais irritante para um desenvolvedor ou engenheiro de dados do que excluir acidentalmente ramificações do git ou redefinir commits quando você não queria. É por isso que tenho o prazer de compartilhar algo que aprendi por experiência própria e que gostaria de ter aprendido antes, que é como usar o git reflog. git reflog é uma daquelas técnicas que definitivamente vale a pena aprender; se você dedicar um pouco de tempo agora, poderá evitar uma grande dor de cabeça no futuro. 

Embora eu vá mostrar a você o site git reflog, que considero muito útil para navegar e se recuperar de erros, também quero recomendar nossos cursos Foundations of Git e Introduction to GitHub Concepts para aprender tudo o que há para saber sobre controle de versão.

O que é o git reflog?

O Git reflog, ou log de referência, é um mecanismo de rastreamento local que registra as atualizações das dicas de ramificação e a referência HEAD em um repositório Git. (No contexto do Git, HEAD refere-se ao commit atual no qual o diretório de trabalho e a área de preparação estão baseados).

Ao contrário do git log, que exibe o histórico de commits com base na ancestralidade, mostrando como os commits estão conectados em um ramo, o git reflog captura todos os movimentos do HEAD, incluindo trocas de ramo, rebases, redefinições e commits. Isso torna o reflog útil para recuperar commits perdidos e depurar ações recentes.

Quando são criadas as entradas de reflog?

As entradas de registro de referência são criadas sempre que você executa ações que alteram o estado das referências HEAD ou de ramificação. Os cenários comuns incluem o seguinte:

• Fazer o commit das alterações usando git commit.

• Verificando um ramo diferente usando git checkout branch_name.

• Criar uma nova ramificação usando git branch new_branch.

• Rebaixamento git rebase

• Redefinição para um commit anterior git reset --hard.

• Mesclando ramificações usando git merge.

Aqui está o código que você usa para rastrear atualizações no repositório local:

git reflog

Usando o git reflog para rastrear atualizações no repositório local. Imagem do autor.

Como você interpreta a saída do git reflog?

Você pode interpretar a saída da seguinte forma:

• HEAD@{0}: A ação mais recente foi a mudança para o ramo HEAD.

• HEAD@{1}: Antes disso, eu havia alterado um tipo de arquivo do formato .xlxs para .csv.

• HEAD@{2}: Fiz a primeira confirmação quando enviei os arquivos para o repositório.

Cada entrada mostra:

• O hash de confirmação (fa82776)

• O índice reflog (HEAD@{0}, HEAD@{1}, etc.)

• Uma descrição da ação realizada (confirmação, checkout, rebase)

Como usar o git reflog

O Git reflog fornece uma maneira de rastrear atualizações de referência e restaurar os estados anteriores do seu repositório. Ao entender como navegar pelas entradas de reflog, você pode recuperar commits perdidos, desfazer alterações e comparar versões anteriores do seu trabalho. 

Comando básico git reflog

Abaixo está o comando reflog básico:

git reflog

O comando acima exibe uma lista de ações recentes que atualizaram referências HEAD ou de ramificação, incluindo commits, trocas de ramificação, redefinições, rebases e muito mais. Cada entrada é indexada, como HEAD@{0}, e HEAD@{1}, para representar sua posição no histórico do reflog.

Referência a estados anteriores

O Git reflog serve como um registro de atualizações de referência anteriores, permitindo-nos localizar e restaurar pontos anteriores no histórico do nosso repositório. Sem ele, essas referências não existiriam e precisaríamos de hashes de confirmação exatos para retornar a estados passados específicos. Agora, vamos explorar como o Git nos permite navegar por esses estados passados usando git checkout.

HEAD@{n}: Refere-se a uma entrada de reflog específica, em que n é o índice. Por exemplo, HEAD@{2} refere-se ao terceiro estado mais recente do HEAD.

git checkout HEAD@{2}

Usando o git checkout para rastrear alterações anteriores. Imagem do autor.

branch@{time}: Refere-se ao estado de uma filial em um momento específico. Por exemplo, main@{1.week.ago} refere-se ao estado do ramo principal há uma semana, enquanto feature@{yesterday} refere-se ao estado do ramo de recursos ontem.

git checkout main@{1.week.ago}

Usando o git checkout para rastrear alterações anteriores. Imagem do autor.

Qualificadores baseados em tempo

git reflog não só nos ajuda a restaurar estados passados, mas também nos permite compará-los. Como o reflog programa atualizações de referência, podemos usá-lo para ver como nosso repositório mudou ao longo do tempo. Agora, vamos ver como o git diff usa as entradas de reflog para comparar os estados passado e presente.

A seguir, exemplos de qualificadores de tempo que facilitam a restauração do repositório para um ponto específico no tempo, em vez de depender apenas dos números de índice do reflog.

git checkout HEAD@{1.minute.ago}     # State from one minute ago

git checkout HEAD@{1.hour.ago}       # State from one hour ago

git checkout HEAD@{1.week.ago}       # State from one week ago

git checkout HEAD@{yesterday}        # State from yesterday

git checkout HEAD@{2024-01-01.12:00:00} # State at a specific timestamp

Comparação de estados anteriores com o git diff

Você pode comparar estados anteriores usando comandos como git diff. O comando a seguir compara o estado atual do ramo principal main@{0} com o estado de um dia atrás, main@{1.day.ago}. O resultado mostrará todas as diferenças entre esses dois instantâneos.

git diff main@{0} main@{1.day.ago}

Comparação de estados anteriores com o git diff. Imagem do autor.

Casos de uso comuns do Git Reflog

O Git reflog é uma ferramenta inestimável para recuperar alterações perdidas, desfazer erros e corrigir contratempos comuns do Git. Veja abaixo alguns cenários práticos em que o site git reflog pode ajudar.

Desfazer uma reinicialização incorreta

Se você redefinir a ramificação por engano usando git reset --hard, poderá usar o reflog para restaurar o estado anterior.

git reset --hard HEAD@{3}

Recuperação de commits perdidos

Se você excluir acidentalmente uma ramificação ou perder commits devido a uma redefinição ou rebase, poderá encontrar o commit perdido usando git reflog.

git reflog

Localize o hash do commit na saída do reflog e verifique:

git checkout <commit-hash>

Depois de verificar o commit perdido, você pode criar uma nova ramificação para preservá-lo:

git branch recovered-branch <commit-hash>

Correção de um rebase malfeito

Se um rebase der errado, você poderá usar git reflog para encontrar o commit pré-rebase e redefinir o ramo. Identificar o commit antes do rebase e redefini-lo.

git reset --hard HEAD@{3}  # Adjust the number based on the reflog output

Restauração de um ramo excluído

Se você excluir acidentalmente um ramo, poderá recuperá-lo usando git reflog. Encontre o último commit conhecido da ramificação excluída e recrie-o:

git branch restored-branch <commit-hash>

Programando o histórico do estoque

O Git reflog também pode ser usado para visualizar o histórico do estoque. O comando abaixo lista as operações de stash, permitindo que você recupere stashes mais antigos, se necessário. 

git reflog stash

Para aplicar uma entrada de estoque anterior, use o seguinte comando:

git stash apply stash@{2}

Confira nosso Git Pull Force: Como substituir uma ramificação local com o tutorial remoto para que você aprenda as práticas recomendadas para substituir alterações locais.

Subcomandos e opções do Git Reflog

O Git fornece vários subcomandos e opções para gerenciar e interagir com reflogs. 

Subcomandos do Git reflog

A seguir, você encontrará um detalhamento estruturado dos principais subcomandos do site git reflog e sua utilização.

git reflog show: Exibe as entradas de reflog para HEAD por padrão ou para uma referência especificada, como uma ramificação.

git reflog show

Usando o git reflog show para exibir entradas para a referência especificada. Imagem do autor.

git reflog list: Esse comando exibe todas as referências com um refluxo. É útil para identificar ramificações e referências HEAD com entradas de reflog armazenadas.

git reflog list

git reflog delete @{}: Limpa entradas antigas de reflog que excedem o limite de tempo especificado. Por exemplo, o comando a seguir remove entradas com mais de 30 dias.

git reflog expire --expire=30.days.ago

git reflog delete @{}: Exclui uma determinada entrada de reflog com base em sua referência e posição. O comando abaixo remove a entrada de reflog no índice 2 para HEAD.

git reflog delete HEAD@{2}

git reflog exists : Verifica se existe um reflog para uma referência específica. Por exemplo, o comando abaixo retorna sucesso se o ramo principal tiver um refluxo.

git reflog exists main

Opções para subcomandos do git reflog

A seguir, você encontrará as opções disponíveis para os subcomandos git reflog e seu uso.

--expire-unreachable=: Remove apenas as entradas do reflog que não podem ser acessadas por nenhuma referência. Por exemplo, o comando abaixo remove entradas de reflog inacessíveis com mais de 7 dias.

git reflog expire --expire-unreachable=7.days.ago

--all: Processa reflogs para todas as referências, não apenas para HEAD. O comando abaixo limpa todos os reflogs com mais de 60 dias em todas as filiais.

git reflog expire --expire=60.days.ago --all

--dry-run: Simula a execução de um comando, mostrando o que seria eliminado sem realmente excluir nada. Por exemplo, o comando abaixo exibe quais entradas seriam removidas.

git reflog expire --expire=30.days.ago --dry-run

--verbose: Fornece uma saída detalhada sobre as ações executadas pelo comando. O comando abaixo mostra detalhes detalhados durante a expiração de entradas antigas de reflog.

git reflog expire --expire=90.days.ago --verbose

Git Reflog vs. Git Reflog. Registro do Git: Principais diferenças

Tanto o site git log quanto o git reflog fornecem informações sobre o histórico de um repositório, mas têm finalidades diferentes. Vamos analisar essas diferenças para entender como cada uma pode ser usada para controle de versão e estratégias de recuperação.

• git log mostra o histórico de commits seguindo a origem dos commits em um ramo. Ele fornece uma visão cronológica de como o conteúdo do repositório evoluiu.

• git reflog registra atualizações de referências como HEAD, branches e stashes, incluindo ações como troca de branches, redefinições, rebases e muito mais. Ele programa alterações que podem não fazer parte do histórico do commit.

• git reflog é estritamente local em seu computador e não é compartilhado com repositórios remotos.

• Embora o git log não possa recuperar os commits que não fazem mais parte da ancestralidade do ramo, o git reflog pode ajudar a recuperar os commits "perdidos" rastreando as atualizações de referência, mesmo que esses commits não possam mais ser acessados de nenhum ramo.

Na tabela abaixo, você encontra um resumo das principais diferenças.

O Git reflog é uma ferramenta poderosa para recuperar commits perdidos e corrigir problemas de histórico, mas para usá-lo com eficácia é preciso ter cuidado. Aqui estão algumas práticas recomendadas que você deve seguir ao trabalhar com o reflog.

• Use o Reflog para recuperação e depuração: Se você acidentalmente redefinir ou fizer o rebase de um ramo incorretamente, consulte git reflog para encontrar uma referência anterior e restaurá-la.

• Seja cauteloso com git reset --hard: git reset --hard pode remover permanentemente alterações não confirmadas. Sempre verifique o reflog primeiro para garantir que você possa se recuperar se algo der errado.

• Mantenha backups antes de executar comandos destrutivos: Para se proteger contra a perda de dados, implemente backups automatizados de seus repositórios Git. Sempre armazene os backups em um local seguro e externo para garantir a capacidade de recuperação em caso de falha de hardware ou outros desastres.

• Não confie apenas no Reflog para uma recuperação de longo prazo: Por padrão, as entradas de reflog são mantidas por 90 dias. Após esse período, eles podem ser coletados pelo lixo e se tornar irrecuperáveis. Envie regularmente seus commits para um repositório remoto para garantir que eles sejam preservados além do reflog local.

• Use git reflog expire para gerenciar entradas antigas: Se o reflog do seu repositório ficar desordenado, remova as entradas mais antigas ou inacessíveis usando git reflog expire.

Conclusão

Para gerenciar com eficácia o histórico de um projeto no Git, você precisa de mais do que apenas comandos básicos. Ao explorar ferramentas avançadas que rastreiam as atualizações de referência, você pode fornecer uma rede de segurança valiosa para recuperar commits perdidos, restaurar ramificações excluídas e corrigir erros. Ao adquirir experiência prática com essas ferramentas, juntamente com comandos como git reset, git checkout e git revert, você pode aumentar significativamente sua proficiência em controle de versão.

Fazer cursos da DataCamp não é apenas uma ótima maneira de aprender, mas também uma ótima maneira de mostrar aos empregadores que você leva o desenvolvimento de software a sério. Para isso, recomendo que você estude nossa postagem do blog As 20 principais perguntas e respostas da entrevista sobre o Git para todos os níveis e faça nosso novo programa de habilidades Git Fundamentals para se tornar um especialista em tudo relacionado ao Git.