¿Cómo recuperas commits perdidos con git reflog?

Question

Accepted Answer

**git reflog** registra dónde ha estado el HEAD de tu rama — cada commit, checkout, reset, rebase, etc. Es una red de seguridad para **recuperar commits "perdidos"** (después de un reset erróneo, rebase fallido o eliminación de rama) que parecen desaparecidos pero siguen siendo recuperables.

## Qué es reflog

```text
The REFLOG logs every movement of HEAD (and branch tips) in YOUR local repo:
  → every commit, checkout, reset, rebase, merge, etc. is recorded with a reference
  → it's LOCAL and includes commits not reachable from any branch (the "lost" ones)
→ Even if you reset/rebase away commits, reflog remembers where they were.
```

## Recuperando trabajo perdido

```bash
git reflog                     # show the history of HEAD movements
# example output:
#   abc123 HEAD@{0}: reset: moving to HEAD~3
#   def456 HEAD@{1}: commit: Important work    ← the "lost" commit!
#   ...

# recover: the lost commit is def456 — get it back
git checkout def456            # inspect it
git branch recovered def456    # create a branch at it (save it)
# or reset back to it:
git reset --hard def456        # restore HEAD to that commit
```

Cuando los commits parecen perdidos (después de `reset --hard`, un rebase fallido o la eliminación de una rama), `git reflog` muestra dónde estaba el HEAD, y puedes recuperar el commit por su hash (revisándolo, creando una rama o reseteando a él).

## Escenarios comunes de recuperación

```text
✓ After git reset --hard (discarded commits) → find them in reflog, reset back
✓ After a bad rebase (rewrote/lost commits) → reflog has the pre-rebase state
✓ After deleting a branch → its last commit is in reflog → recreate the branch
✓ "Detached HEAD" commits that seem orphaned → reflog finds them
→ As long as commits existed locally, reflog usually can recover them (until GC, ~weeks).
```

## Por qué es importante

Comprender `git reflog` es valioso como una **red de seguridad para recuperar trabajo perdido**, así que es un conocimiento práctico importante que puede salvarte de errores que parecen catastróficos.

Las operaciones de Git que reescriben el historial o mueven el HEAD — `reset --hard`, rebases fallidos, eliminar ramas — pueden hacer que los commits **parezcan perdidos**, lo cual es alarmante y parece irreversible.

El punto crucial es que estos commits generalmente **no están realmente desaparecidos**: `git reflog` registra cada movimiento del HEAD localmente (cada commit, checkout, reset, rebase), incluyendo commits que ya no son alcanzables desde ninguna rama, así que recuerda dónde estaban los commits "perdidos".

Esto hace que reflog sea una poderosa **herramienta de recuperación** — cuando el trabajo parece perdido después de un reset erróneo, un rebase fallido o la eliminación de una rama, puedes usar `git reflog` para encontrar el hash del commit y recuperarlo (revisándolo, creando una rama en él, o reseteando de vuelta a él).

Comprender los **escenarios comunes de recuperación** (recuperación después de `reset --hard`, rebases malos, eliminación de rama, y commits huérfanos en estado detached-HEAD) y que la recuperación funciona mientras los commits existieron localmente (hasta la recolección de basura, típicamente semanas después) es un conocimiento práctico valioso.

Esta red de seguridad es reconfortante y genuinamente útil — significa que muchas situaciones de "¡Perdí mi trabajo!" son recuperables, eliminando gran parte del miedo alrededor de las operaciones que reescriben el historial de Git.

Ya que los errores que parecen perder commits son comunes (especialmente cuando se aprende o se usan comandos poderosos como reset y rebase), y ya que reflog es la herramienta que los recupera (a menudo convirtiendo un pánico en una corrección rápida), comprender `git reflog` — qué registra, cómo recuperar commits perdidos, y los escenarios comunes de recuperación — es conocimiento valioso y prácticamente relevante de Git como una red de seguridad esencial, una herramienta que proporciona confianza para usar las características poderosas de Git sabiendo que el trabajo perdido generalmente puede recuperarse, y un conocimiento genuinamente reconfortante para cualquier desarrollador.