0Pricing
DevOps Bootcamp · Aula

Git Reflog e recuperação do histórico

Domine o `git reflog` para recuperar commits ou ramificações perdidos, criando uma rede de segurança para o seu trabalho.

Git Reflog e recuperação do histórico é uma aula grátis de DevOps Bootcamp no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de DevOps Bootcamp, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de DevOps Bootcamp inclui 4 aulas no total.

O que é o registro de referências do Git?

Já excluiu acidentalmente uma ramificação ou redefiniu para a confirmação errada? Não entre em pânico! O Git tem uma poderosa rede de segurança chamada registro de referências.

O registro de referências (registro de referências) é um registro de onde o seu HEAD e os ponteiros das ramificações estiveram no seu repositório local.

Como o registro de referências acompanha o histórico

Ao contrário do histórico de confirmações (git log), que acompanha as alterações nos arquivos do seu projeto, o registro de referências acompanha as alterações nas referências do seu repositório.

Sempre que o seu HEAD (a sua confirmação atual) ou um ponteiro de ramificação se move, o Git registra esse evento no registro de referências. Isso inclui:

  • Confirmar alterações
  • Alternar entre ramificações
  • Mesclar ou reorganizar a base
  • Executar uma redefinição
  • Clonar um repositório

Visualizando o seu registro de referências

Para ver o seu registro de referências, basta usar o comando git reflog. Ele mostra uma lista de ações e o estado do seu HEAD naquele momento.

Vamos simular algumas ações e depois visualizar o registro de referências:

git init my_repo
cd my_repo

echo "First line" > file.txt
git add file.txt
git commit -m "Initial commit"

echo "Second line" >> file.txt
git add file.txt
git commit -m "Add second line"

git reflog

Decodificando entradas do registro de referências

Cada entrada do registro de referências tem um formato específico. Vamos analisar uma entrada típica que você pode encontrar:

a1b2c3d HEAD@{0}: commit: Add new feature

  • a1b2c3d: O hash SHA-1 da confirmação em que o HEAD estava naquele momento.
  • HEAD@{0}: Este é o "ponteiro da entrada do registro de referências". @{0} é o estado mais recente, @{1} é o estado anterior e assim por diante.
  • commit: Add new feature: Uma descrição da ação que fez o HEAD se mover.

Esses ponteiros são essenciais para a recuperação!

Cenário: recuperando uma confirmação perdida

Imagine que você fez uma confirmação e depois a desfez acidentalmente com git reset --soft HEAD~1. A sua confirmação não está mais no histórico da ramificação atual, mas não desapareceu de verdade!

O registro de referências se lembra dela. Vamos simular esse erro comum:

git init my_project_recovery
cd my_project_recovery

echo "Initial content" > start.txt
git add start.txt
git commit -m "Initial commit"

echo "Important feature" > feature.txt
git add feature.txt
git commit -m "Added an important feature"

# Oops! Accidentally reset
git reset --soft HEAD~1

git reflog

Trazendo a confirmação de volta

Depois da redefinição, se você executar git reflog, verá uma entrada para a confirmação "Added an important feature", talvez como HEAD@{1} ou algo semelhante.

Para recuperá-la, você pode usar git reset com a entrada do registro de referências. Por exemplo, se o hash da confirmação perdida fosse abcdefg ou se a entrada correspondente fosse HEAD@{1}:

# Assuming the lost commit was HEAD@{1} in the reflog
git reset --hard HEAD@{1}

# Or using the specific commit hash from reflog
# git reset --hard abcdefg

# Now, check your log. The commit is back!
git log --oneline

Cenário: recuperando uma ramificação excluída

E se você excluísse acidentalmente uma ramificação inteira antes de mesclá-la ou achasse que não precisava mais dela?

As ramificações são apenas ponteiros para confirmações. Se você excluir uma ramificação, as confirmações para as quais ela apontava não serão removidas imediatamente do seu repositório. O registro de referências ainda se lembra de onde estava o HEAD dessa ramificação!

Restaurando uma ramificação a partir do registro de referências

Digamos que você tivesse uma ramificação chamada feature-x, trabalhasse nela e depois a excluísse com git branch -D feature-x.

Quando você executar git reflog, poderá ver uma entrada como:

1234567 HEAD@{5}: branch: Created branch feature-x ou
abcdefg HEAD@{2}: checkout: moving from feature-x to master

Você pode usar o hash da confirmação (por exemplo, 1234567 ou abcdefg) da entrada do registro de referências em que a ramificação estava ativa para recriá-la:

# Assume 'feature-x' was deleted and its last commit was '1234567'

# Create a new branch pointing to that commit
git branch feature-x-recovered 1234567

# Now, check out your recovered branch
git checkout feature-x-recovered

# Verify its history
git log --oneline

As entradas do registro de referências expiram

Embora o registro de referências seja uma poderosa rede de segurança, suas entradas não duram para sempre. O Git remove entradas antigas do registro de referências depois de determinado período.

  • Por padrão, as entradas alcançáveis (a partir do seu HEAD atual) expiram após 90 dias.
  • As entradas inalcançáveis (por exemplo, de ramificações excluídas ou confirmações que já não são referenciadas) expiram após 30 dias.

Isso significa que é melhor recuperar o trabalho "perdido" o quanto antes!

Desafio de recuperação com o registro de referências

Você criou uma nova ramificação de funcionalidade, fez várias confirmações e depois a excluiu acidentalmente sem mesclá-la. Você executa git reflog e vê esta entrada:

...
c0ffee1 HEAD@{3}: commit: Implement new user profile page
bada55e HEAD@{4}: checkout: moving from feature/profile to main
...

Qual sequência de comandos recriaria corretamente a sua ramificação feature/profile, apontando para a confirmação mais recente que ela tinha antes da exclusão?

Registro de referências: sua rede de segurança do Git

Você aprendeu a usar git reflog, uma ferramenta essencial para recuperar trabalho "perdido" no seu repositório Git local. Lembre-se:

  • Ele registra onde o HEAD e os ponteiros das ramificações estiveram.
  • Use git reflog para visualizar esse histórico.
  • Você pode recuperar confirmações ou ramificações usando git reset ou git branch com entradas do registro de referências (HEAD@{n} ou hashes de confirmações).
  • As entradas do registro de referências expiram, portanto aja rapidamente se precisar recuperar algo!

Mantenha o histórico do Git organizado, mas saiba que o registro de referências está disponível para emergências!

Perguntas Frequentes

A aula “Git Reflog e recuperação do histórico” é grátis?

Sim — o texto completo de “Git Reflog e recuperação do histórico” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de DevOps Bootcamp, atualize para CoddyKit PRO. O curso de DevOps Bootcamp inclui 4 aulas no total.

O que vou aprender em “Git Reflog e recuperação do histórico”?

Domine o `git reflog` para recuperar commits ou ramificações perdidos, criando uma rede de segurança para o seu trabalho. Você pratica DevOps Bootcamp com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar DevOps Bootcamp?

Nenhuma experiência prévia é necessária. DevOps Bootcamp no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “Git Reflog e recuperação do histórico”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de DevOps Bootcamp?

Sim. Cada aula de DevOps Bootcamp inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Git Reflog e recuperação do histórico
  2. Git Bisect para depuração
  3. Manutenção e organização do repositório
  4. Reescrevendo o Histórico com git filter-repo
← Voltar para DevOps Bootcamp