Wie stellst du verlorene Commits mit git reflog wieder her?

Question

Accepted Answer

**git reflog** zeichnet auf, wo sich der HEAD deines Branches befunden hat — jeden Commit, jedes Checkout, jeden Reset, jeden Rebase usw. Es ist ein Sicherheitsnetz zum **Wiederherstellen von "verlorenen" Commits** (nach einem fehlgeschlagenen Reset, Rebase oder Löschen von Branches), die verloren erscheinen, aber noch wiederherstellbar sind.

## Was reflog ist

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

## Verlorene Arbeit wiederherstellen

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

Wenn Commits verloren erscheinen (nach `reset --hard`, einem fehlgeschlagenen Rebase oder dem Löschen eines Branches), zeigt `git reflog`, wo der HEAD war, und du kannst den Commit über seinen Hash wiederherstellen (indem du ihn auscheckst, einen Branch erstellst oder dich zu ihm zurücksetzt).

## Häufige Wiederherstellungsszenarien

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

## Warum es wichtig ist

Das Verständnis von `git reflog` ist wertvoll als **Sicherheitsnetz zur Wiederherstellung verlorener Arbeit**, daher ist es wichtiges praktisches Wissen, das dich vor scheinbar katastrophalen Fehlern bewahren kann.

Git-Operationen, die die Historie umschreiben oder den HEAD verschieben — `reset --hard`, fehlgeschlagene Rebases, Löschen von Branches — können dazu führen, dass Commits **verloren erscheinen**, was beängstigend wirkt und irreversibel zu sein scheint.

Die entscheidende Erkenntnis ist, dass diese Commits normalerweise **eigentlich nicht weg sind**: `git reflog` zeichnet lokal jede Bewegung des HEAD auf (jeden Commit, jeden Checkout, jeden Reset, jeden Rebase), einschließlich Commits, die nicht mehr von einem Branch erreichbar sind, daher "erinnert" es sich, wo "verlorene" Commits waren.

Dies macht reflog zu einem leistungsstarken **Wiederherstellungswerkzeug** — wenn Arbeit nach einem fehlgeschlagenen Reset, einem fehlgeschlagenen Rebase oder einem gelöschten Branch verloren erscheint, kannst du `git reflog` verwenden, um den Hash des Commits zu finden und ihn wiederherzustellen (indem du ihn auscheckst, einen Branch darin erstellst oder dich zu ihm zurücksetzt).

Das Verständnis der **häufigen Wiederherstellungsszenarien** (Wiederherstellung nach `reset --hard`, fehlgeschlagenen Rebases, Löschen von Branches und verwaisten Commits im detached-HEAD-Modus) und dass die Wiederherstellung funktioniert, solange die Commits lokal existiert haben (bis zur Garbage Collection, normalerweise Wochen später), ist wertvoll praktisches Wissen.

Dieses Sicherheitsnetz ist beruhigend und genuinely nützlich — es bedeutet, dass viele "Ich habe meine Arbeit verloren!"-Situationen wiederherstellbar sind und viel der Angst vor Gits History-rewriting-Operationen wegnehmen.

Da Fehler, die zu verloren gegangenen Commits zu führen scheinen, häufig sind (besonders beim Lernen oder bei der Verwendung von leistungsstarken Befehlen wie reset und rebase), und da reflog das Werkzeug ist, das sie wiederherstellt (oft eine Panik in eine schnelle Behebung umwandelnd), ist das Verständnis von `git reflog` — was es aufzeichnet, wie man verlorene Commits wiederherstellt und die häufigen Wiederherstellungsszenarien — wertvoll praktisches Git-Wissen als essentielles Sicherheitsnetz, ein Werkzeug, das Vertrauen bietet, um Gits leistungsstarke Features zu nutzen, da verlorene Arbeit normalerweise wiederhergestellt werden kann, und ein genuinely beruhigendes Stück Wissen für jeden Entwickler.