Comment récupérer les commits perdus avec git reflog?

Question

Accepted Answer

**git reflog** enregistre où votre branche HEAD a été — chaque commit, checkout, reset, rebase, etc. C'est un filet de sécurité pour **récupérer les commits « perdus »** (après un mauvais reset, rebase ou suppression de branche) qui semblent disparus mais sont toujours récupérables.

## Qu'est-ce que 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.
```

## Récupérer le travail perdu

```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
```

Quand les commits semblent perdus (après `reset --hard`, un rebase échoué ou la suppression d'une branche), `git reflog` montre où HEAD se trouvait, et vous pouvez récupérer le commit par son hash (en le vérifiant, en créant une branche ou en effectuant un reset à celui-ci).

## Scénarios de récupération courants

```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).
```

## Pourquoi c'est important

Comprendre `git reflog` est précieux comme **filet de sécurité pour récupérer le travail perdu**, c'est donc une connaissance pratique importante qui peut vous sauver de les erreurs qui semblent catastrophiques.

Les opérations Git qui réécrivent l'historique ou déplacent HEAD — `reset --hard`, les rebases échoués, la suppression de branches — peuvent rendre les commits **apparemment perdus**, ce qui est alarmant et semble irréversible.

L'idée clé est que ces commits ne sont généralement **pas réellement disparus** : `git reflog` enregistre chaque mouvement de HEAD localement (chaque commit, checkout, reset, rebase), y compris les commits ne pouvant plus être atteints à partir d'une branche, donc il se souvient où se trouvaient les commits « perdus ».

Cela fait de reflog un puissant **outil de récupération** — quand le travail semble perdu après un mauvais reset, un rebase échoué ou une branche supprimée, vous pouvez utiliser `git reflog` pour trouver le hash du commit et le récupérer (en le vérifiant, en créant une branche à celui-ci ou en effectuant un reset vers celui-ci).

Comprendre les **scénarios de récupération courants** (récupération après `reset --hard`, mauvais rebases, suppression de branche et commits orphelins en mode détaché) et que la récupération fonctionne tant que les commits existaient localement (jusqu'à la collecte des ordures, généralement des semaines plus tard) est une connaissance pratique précieuse.

Ce filet de sécurité est rassurant et véritablement utile — cela signifie que de nombreuses situations « J'ai perdu mon travail! » sont récupérables, ce qui élimine beaucoup de crainte autour des opérations de réécriture d'historique de Git.

Puisque les erreurs qui semblent faire perdre des commits sont courantes (surtout lors de l'apprentissage ou de l'utilisation de commandes puissantes comme reset et rebase), et puisque reflog est l'outil qui les récupère (transformant souvent une panique en un correctif rapide), comprendre `git reflog` — ce qu'il enregistre, comment récupérer les commits perdus et les scénarios de récupération courants — est une connaissance Git précieuse, pratiquement pertinente comme filet de sécurité essentiel, un outil qui donne confiance pour utiliser les fonctionnalités puissantes de Git en sachant que le travail perdu peut généralement être récupéré, et une connaissance véritablement rassurante pour tout développeur.