Hoe herstel je verloren commits met git reflog?

Question

Accepted Answer

**git reflog** registreert waar de HEAD van je branch is geweest — elke commit, checkout, reset, rebase, etc. Het is een veiligheidsnet voor het **herstellen van "verloren" commits** (na een slechte reset, rebase of branch deletion) die weg lijken te zijn maar nog steeds herstelbaar zijn.

## Wat reflog is

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

## Verloren werk herstellen

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

Wanneer commits verloren lijken te zijn (na `reset --hard`, een mislukte rebase, of het verwijderen van een branch), toont `git reflog` waar HEAD was, en kun je de commit herstellen via zijn hash (door deze uit te checken, een branch te maken, of ernaar terug te zetten).

## Veelvoorkomende herstelscenario's

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

## Waarom het belangrijk is

Het begrijpen van `git reflog` is waardevol als een **veiligheidsnet voor het herstellen van verloren werk**, dus het is belangrijk praktisch kennis die je kan redden van ogenschijnlijk catastrofale fouten.

Git-bewerkingen die de geschiedenis herschrijven of HEAD verplaatsen — `reset --hard`, mislukte rebases, het verwijderen van branches — kunnen commits **verloren doen lijken**, wat alarmerend is en onherstelbaar lijkt.

Het cruciale inzicht is dat deze commits meestal **niet werkelijk weg zijn**: `git reflog` registreert lokaal elke beweging van HEAD (elke commit, checkout, reset, rebase), inclusief commits die niet langer bereikbaar zijn vanuit een branch, dus het onthoudt waar "verloren" commits waren.

Dit maakt reflog een krachtig **hersteltool** — wanneer werk verloren lijkt te zijn na een slechte reset, een mislukte rebase, of een verwijderde branch, kun je `git reflog` gebruiken om de hash van de commit te vinden en deze terug te herstellen (door deze uit te checken, een branch erbij te maken, of er terug naar toe te zetten).

Het begrijpen van de **veelvoorkomende herstelscenario's** (herstel na `reset --hard`, slechte rebases, branch deletion, en verweesde detached-HEAD commits) en dat herstel werkt zolang de commits lokaal bestonden (tot garbage collection, meestal weken later) is waardevol praktisch kennis.

Dit veiligheidsnet is geruststellend en echt nuttig — het betekent dat veel "Ik ben mijn werk kwijt!" situaties herstelbaar zijn, wat veel van de angst rond Git's history-rewriting operaties wegneemt.

Omdat fouten die commits verloren doen lijken veel voorkomen (vooral bij het leren of gebruiken van krachtige commando's zoals reset en rebase), en omdat reflog de tool is die ze herstelt (vaak een paniek in een snelle fix veranderend), is het begrijpen van `git reflog` — wat het registreert, hoe je verloren commits herstelt, en de veelvoorkomende herstelscenario's — waardevol, praktisch relevant Git-kennis als een essentieel veiligheidsnet, een tool die vertrouwen geeft om Git's krachtige functies te gebruiken wetende dat verloren werk meestal kan worden hersteld, en een genuinely geruststellend stuk kennis voor elke ontwikkelaar.