Git Reflog: Verstehen und Verwenden von Referenzprotokollen in Git

Es gibt nichts Ärgerlicheres für einen Entwickler oder Datentechniker als versehentlich Git-Branches zu löschen oder Commits zurückzusetzen, wenn du das nicht wolltest. Deshalb freue ich mich, dir etwas mitzuteilen, das ich aus eigener Erfahrung gelernt habe und das ich gerne früher gelernt hätte: git reflog. git reflog ist eine der Techniken, die es definitiv wert ist, gelernt zu werden; wenn du jetzt ein bisschen Zeit investierst, kannst du dir später große Kopfschmerzen ersparen. 

Ich zeige dir zwar git reflog, was ich sehr hilfreich finde, um zu navigieren und Fehler zu beheben, aber ich möchte dir auch unsere Kurse Foundations of Git und Introduction to GitHub Concepts empfehlen, in denen du alles über Versionskontrolle lernst, was es zu wissen gibt.

Was ist git reflog?

Git reflog, oder Referenzprotokoll, ist ein lokaler Nachverfolgungsmechanismus, der Aktualisierungen von Branch Tips und der HEAD-Referenz in einem Git-Repository aufzeichnet. (Im Kontext von Git bezieht sich HEAD auf den aktuellen Commit, auf dem dein Arbeitsverzeichnis und dein Staging-Bereich basieren).

Im Gegensatz zu git log, das die Commit-Historie auf Basis der Abstammung anzeigt und zeigt, wie Commits in einem Branch miteinander verbunden sind, erfasst git reflog alle Bewegungen des HEAD, einschließlich Branch-Switches, Rebases, Resets und Commits. Das macht reflog nützlich, um verlorene Commits wiederherzustellen und die letzten Aktionen zu debuggen.

Wann werden Reflog-Einträge erstellt?

Reflog-Einträge werden immer dann erstellt, wenn du Aktionen durchführst, die den Status von HEAD- oder Branch-Referenzen ändern. Zu den häufigsten Szenarien gehören die folgenden:

• Übertragen von Änderungen mit git commit.

• Einen anderen Zweig mit git checkout branch_name auschecken.

• Einen neuen Zweig mit git branch new_branch erstellen.

• Neuausrichtung git rebase

• Zurücksetzen auf einen früheren Commit git reset --hard.

• Zusammenführen von Zweigen mit git merge.

Hier ist der Code, mit dem du Updates im lokalen Lernpfad verfolgen kannst:

git reflog

Verwendung von git reflog, um Aktualisierungen im lokalen Repository zu verfolgen. Bild vom Autor.

Wie interpretierst du die Ausgabe von git reflog?

Du kannst die Ausgabe wie folgt interpretieren:

• HEAD@{0}: Die letzte Aktion war der Wechsel zum HEAD-Zweig.

• HEAD@{1}: Zuvor hatte ich einen Dateityp von .xlxs in das Format .csv geändert.

• HEAD@{2}: Ich habe den ersten Commit gemacht, als ich die Dateien ins Repository gestellt habe.

Jeder Eintrag zeigt:

• Der Commit-Hash (fa82776)

• Der Reflog-Index (HEAD@{0}, HEAD@{1}, etc.)

• Eine Beschreibung der durchgeführten Aktion (Commit, Checkout, Rebase)

Wie man git reflog benutzt

Mit Git reflog kannst du Lernpfade verfolgen und die vorherigen Zustände deines Repositorys wiederherstellen. Wenn du weißt, wie du durch die Reflog-Einträge navigieren kannst, kannst du verlorene Commits wiederherstellen, Änderungen rückgängig machen und frühere Versionen deiner Arbeit vergleichen. 

Grundlegender git reflog-Befehl

Im Folgenden findest du den grundlegenden Befehl reflog:

git reflog

Der obige Befehl zeigt eine Liste der letzten Aktionen an, die HEAD- oder Branch-Referenzen aktualisiert haben, darunter Commits, Branch-Switches, Resets, Rebases und mehr. Jeder Eintrag ist mit einem Index versehen, z. B. HEAD@{0} und HEAD@{1}, um seine Position in der Reflog-Historie darzustellen.

Verweis auf vergangene Staaten

Git reflog dient als Aufzeichnung vergangener Referenzaktualisierungen, die es uns ermöglicht, frühere Punkte in der Geschichte unseres Repositorys zu finden und wiederherzustellen. Ohne sie gäbe es diese Referenzen nicht, und wir bräuchten exakte Commit-Hashes, um zu bestimmten vergangenen Zuständen zurückzukehren. Jetzt wollen wir herausfinden, wie wir mit Git durch diese vergangenen Zustände navigieren können: git checkout.

HEAD@{n}: Verweist auf einen bestimmten Reflog-Eintrag, wobei n der Index ist. Zum Beispiel bezieht sich HEAD@{2} auf den drittjüngsten Zustand von HEAD.

git checkout HEAD@{2}

Mit git checkout kannst du vergangene Änderungen verfolgen. Bild vom Autor.

branch@{time}: Bezieht sich auf den Zustand eines Zweigs zu einem bestimmten Zeitpunkt. Zum Beispiel bezieht sich main@{1.week.ago} auf den Stand des Hauptzweigs vor einer Woche und feature@{yesterday} auf den Stand des Feature-Zweigs von gestern.

git checkout main@{1.week.ago}

Mit git checkout kannst du vergangene Änderungen verfolgen. Bild vom Autor.

Zeitbasierte Qualifikanten

git reflog hilft uns nicht nur, vergangene Zustände wiederherzustellen, sondern ermöglicht uns auch, sie zu vergleichen. Da reflog die Aktualisierungen von Referenzen verfolgt, können wir damit feststellen, wie sich unser Repository im Laufe der Zeit verändert hat. Sehen wir uns nun an, wie git diff die Reflog-Einträge nutzt, um vergangene und aktuelle Zustände zu vergleichen.

Im Folgenden findest du Beispiele für Zeitqualifikatoren, mit denen du dein Repository ganz einfach zu einem bestimmten Zeitpunkt wiederherstellen kannst, anstatt dich nur auf die Reflog-Indexnummern zu verlassen.

git checkout HEAD@{1.minute.ago}     # State from one minute ago

git checkout HEAD@{1.hour.ago}       # State from one hour ago

git checkout HEAD@{1.week.ago}       # State from one week ago

git checkout HEAD@{yesterday}        # State from yesterday

git checkout HEAD@{2024-01-01.12:00:00} # State at a specific timestamp

Vergangene Zustände mit git diff vergleichen

Du kannst vergangene Zustände mit Befehlen wie git diff vergleichen. Der folgende Befehl vergleicht den aktuellen Zustand des Hauptzweigs main@{0} mit dem Zustand von vor einem Tag, main@{1.day.ago}. Die Ausgabe zeigt alle Unterschiede zwischen diesen beiden Schnappschüssen an.

git diff main@{0} main@{1.day.ago}

Vergleich von vergangenen Zuständen mit git diff. Bild vom Autor.

Häufige Anwendungsfälle für Git Reflog

Git reflog ist ein unschätzbares Werkzeug, um verlorene Änderungen wiederherzustellen, Fehler rückgängig zu machen und häufige Git-Pannen zu beheben. Im Folgenden sind einige praktische Szenarien aufgeführt, bei denen git reflog helfen kann.

Rückgängig machen einer falschen Rückstellung

Wenn du deinen Zweig versehentlich mit git reset --hard zurückgesetzt hast, kannst du mit reflog den vorherigen Zustand wiederherstellen.

git reset --hard HEAD@{3}

Verlorene Commits wiederherstellen

Wenn du versehentlich einen Branch löschst oder Commits durch einen Reset oder Rebase verlierst, kannst du den verlorenen Commit mit git reflog finden.

git reflog

Finde den Commit-Hash in der Reflog-Ausgabe und überprüfe ihn:

git checkout <commit-hash>

Sobald du den verlorenen Commit verifiziert hast, kannst du einen neuen Zweig erstellen, um ihn zu erhalten:

git branch recovered-branch <commit-hash>

Eine verpfuschte Umbasierung reparieren

Wenn ein Rebase schief geht, kannst du mit git reflog den Commit vor dem Rebase finden und deinen Branch zurücksetzen. Identifiziere den Commit vor dem Rebase und setze ihn zurück.

git reset --hard HEAD@{3}  # Adjust the number based on the reflog output

Wiederherstellung eines gelöschten Zweigs

Wenn du versehentlich einen Zweig gelöscht hast, kannst du ihn mit git reflog wiederherstellen. Finde den letzten bekannten Commit des gelöschten Zweigs und stelle ihn wieder her:

git branch restored-branch <commit-hash>

Lernpfad für das Versteck

Git reflog kann auch verwendet werden, um die Stash-Historie einzusehen. Der folgende Befehl listet die Stash-Operationen auf, so dass du bei Bedarf ältere Stashes wiederherstellen kannst. 

git reflog stash

Um einen früheren Stash-Eintrag zu übernehmen, verwende den folgenden Befehl:

git stash apply stash@{2}

Schau dir unsere Git Pull Force an: Wie man einen lokalen Zweig mit einem entfernten Tutorial überschreibt, um die besten Methoden zum Überschreiben lokaler Änderungen zu lernen.

Git Reflog Unterbefehle und Optionen

Git bietet mehrere Unterbefehle und Optionen für die Verwaltung und Interaktion mit Reflogs. 

Git reflog Unterbefehle

Im Folgenden findest du eine strukturierte Aufschlüsselung der wichtigsten git reflog Unterbefehle und ihrer Verwendung.

git reflog show: Zeigt standardmäßig die Reflog-Einträge für HEAD oder für eine bestimmte Referenz wie einen Branch an.

git reflog show

Mit git reflog show kannst du die Einträge für die angegebene Referenz anzeigen. Bild vom Autor.

git reflog list: Dieser Befehl zeigt alle Referenzen mit einem Reflog an. Sie ist nützlich, um Zweige und HEAD-Referenzen mit gespeicherten Reflog-Einträgen zu identifizieren.

git reflog list

git reflog delete @{}: Bereinigt alte Reflog-Einträge, die das angegebene Zeitlimit überschreiten. Der folgende Befehl entfernt zum Beispiel Einträge, die älter als 30 Tage sind.

git reflog expire --expire=30.days.ago

git reflog delete @{}: Löscht einen bestimmten Reflog-Eintrag basierend auf seiner Referenz und Position. Mit dem folgenden Befehl wird der Reflog-Eintrag unter dem Index 2 für HEAD entfernt.

git reflog delete HEAD@{2}

git reflog exists : Überprüft, ob ein Reflog für eine bestimmte Referenz existiert. Der folgende Befehl gibt zum Beispiel einen Erfolg zurück, wenn der Hauptzweig einen Reflog hat.

git reflog exists main

Optionen für git reflog Unterbefehle

Im Folgenden sind die verfügbaren Optionen für die git reflog Unterbefehle und ihre Verwendung aufgeführt.

--expire-unreachable=: Löscht nur die Reflog-Einträge, die von keiner Referenz aus erreichbar sind. Der folgende Befehl entfernt zum Beispiel unerreichbare Reflog-Einträge, die älter als 7 Tage sind.

git reflog expire --expire-unreachable=7.days.ago

--all: Verarbeitet Reflogs für alle Referenzen, nicht nur HEAD. Der folgende Befehl bereinigt alle Reflogs, die älter als 60 Tage sind, in allen Zweigen.

git reflog expire --expire=60.days.ago --all

--dry-run: Simuliert die Ausführung eines Befehls und zeigt, was gelöscht werden würde, ohne tatsächlich etwas zu löschen. Der folgende Befehl zeigt zum Beispiel an, welche Einträge entfernt werden würden.

git reflog expire --expire=30.days.ago --dry-run

--verbose: Bietet eine detaillierte Ausgabe über die Aktionen, die der Befehl ausführt. Der folgende Befehl zeigt ausführliche Details zum Auslaufen alter Reflog-Einträge.

git reflog expire --expire=90.days.ago --verbose

Git Reflog vs. Git Log: Die wichtigsten Unterschiede

Sowohl git log als auch git reflog bieten Einblicke in die Geschichte eines Repositorys, aber sie dienen unterschiedlichen Zwecken. Schauen wir uns diese Unterschiede an, um zu verstehen, wie sie für Versionskontrolle und Wiederherstellungsstrategien genutzt werden können.

• git log zeigt die Commit-Historie an, indem sie die Abstammung der Commits in einem Branch verfolgt. Sie bietet einen chronologischen Überblick über die Entwicklung der Inhalte des Repositorys.

• git reflog erfasst Aktualisierungen von Referenzen wie HEAD, Branches und Stashes, einschließlich Aktionen wie Branch Switches, Resets, Rebases und mehr. Er verfolgt Änderungen, die möglicherweise nicht Teil des Commit-Ahnens sind.

• git reflog ist ausschließlich lokal auf deinem Rechner und wird nicht mit anderen Repositories geteilt.

• Während git log keine Commits wiederherstellen kann, die nicht mehr Teil der Branch-Abstammung sind, kann git reflog dabei helfen, "verlorene" Commits wiederherzustellen, indem es Referenzaktualisierungen verfolgt, selbst wenn diese Commits von keinem Branch mehr erreichbar sind.

Die folgende Tabelle fasst die wichtigsten Unterschiede zusammen.

Git reflog ist ein mächtiges Werkzeug, um verlorene Commits wiederherzustellen und History-Probleme zu beheben, aber der effektive Einsatz erfordert Vorsicht. Hier sind einige Best Practices, die du bei der Arbeit mit reflog beachten solltest.

• Verwende Reflog zur Wiederherstellung und Fehlersuche: Wenn du einen Zweig versehentlich zurückgesetzt oder neu geordnet hast, kannst du unter git reflog nach einer früheren Referenz suchen und sie wiederherstellen.

• Sei vorsichtig mit git reset --hard: git reset --hard kann unbestätigte Änderungen dauerhaft entfernen. Überprüfe immer zuerst das Reflog, um sicherzustellen, dass du es wiederherstellen kannst, wenn etwas schief läuft.

• Führe Backups durch, bevor du destruktive Befehle ausführst: Um dich vor Datenverlust zu schützen, solltest du automatische Backups deiner Git-Repositories einrichten. Bewahre Backups immer an einem sicheren Ort außerhalb des Unternehmens auf, um die Wiederherstellbarkeit im Falle eines Hardwareausfalls oder anderer Katastrophen zu gewährleisten.

• Verlasse dich für eine langfristige Erholung nicht allein auf Reflog: Standardmäßig werden die Reflog-Einträge 90 Tage lang aufbewahrt. Nach diesem Zeitraum werden sie möglicherweise gelöscht und sind nicht mehr wiederherstellbar. Pushe deine Commits regelmäßig in ein entferntes Repository, um sicherzustellen, dass sie über dein lokales Reflog hinaus erhalten bleiben.

• Verwende git reflog expire, um alte Einträge zu verwalten: Wenn das Reflog deines Repositorys unübersichtlich wird, kannst du ältere oder unerreichbare Einträge mit git reflog expire löschen.

Fazit

Um den Verlauf eines Projekts in Git effektiv zu verwalten, braucht es mehr als nur die grundlegenden Befehle. Die Erforschung fortgeschrittener Tools, die Referenzaktualisierungen verfolgen, kann ein wertvolles Sicherheitsnetz sein, um verlorene Commits wiederherzustellen, gelöschte Zweige wiederherzustellen und Fehler zu korrigieren. Wenn du praktische Erfahrungen mit diesen Werkzeugen und Befehlen wie git reset, git checkout und git revert sammelst, kannst du deine Fähigkeiten in der Versionskontrolle deutlich verbessern.

Die Teilnahme an DataCamp-Kursen ist nicht nur eine großartige Möglichkeit zu lernen, sondern auch eine gute Möglichkeit, Arbeitgebern zu signalisieren, dass du die Softwareentwicklung ernst nimmst. Zu diesem Zweck empfehle ich dir, unseren Blogbeitrag Top 20 Git Interview Questions and Answers for All Levels zu lesen und unseren neuen Lernpfad Git Fundamentals zu besuchen, um ein Experte in Sachen Git zu werden.