Git Reflog: Referentielogs in Git begrijpen en gebruiken

Er is weinig zo frustrerend voor een developer of data engineer als per ongeluk git-branches verwijderen of commits terugzetten terwijl je dat niet wilde. Daarom deel ik graag iets wat ik zelf heb moeten ondervinden en wat ik eerder had willen weten: hoe je git reflog gebruikt. git reflog is zo’n techniek die het absoluut waard is om te leren; met een beetje tijd nu bespaar je jezelf later een hoop gedoe. 

Hoewel ik je git reflog laat zien—dat ik erg handig vind om te navigeren en te herstellen van fouten—raad ik je ook onze cursussen Foundations of Git en Introduction to GitHub Concepts aan om alles te leren over versiebeheer.

Wat is git reflog?

Git reflog, of referentielog, is een lokaal volgmechanisme dat updates aan branch-tips en de HEAD-referentie in een Git-repository registreert. (In de context van Git verwijst HEAD naar de huidige commit waarop je werkdirectory en staging area zijn gebaseerd.)

In tegenstelling tot git log, dat de commithistorie op basis van afstamming toont—hoe commits in een branch met elkaar verbonden zijn—legt git reflog alle bewegingen van HEAD vast, inclusief branchwissels, rebases, resets en commits. Daardoor is reflog nuttig om verloren commits terug te halen en recente acties te debuggen.

Wanneer worden reflog-items aangemaakt?

Reflog-items worden aangemaakt wanneer je acties uitvoert die de status van HEAD of branch-referenties veranderen. Veelvoorkomende scenario’s zijn onder andere:

• Wijzigingen committen met git commit.

• Een andere branch uitchecken met git checkout branch_name.

• Een nieuwe branch aanmaken met git branch new_branch.

• Rebasen git rebase

• Resetten naar een eerdere commit git reset --hard.

• Branches mergen met git merge.

Hier is de code die je gebruikt om updates in de lokale repository te volgen:

git reflogMogelijk gemaakt door

git reflog gebruiken om updates in de lokale repository bij te houden. Afbeelding door de auteur.

Hoe interpreteer je de uitvoer van git reflog?

Je kunt de uitvoer als volgt interpreteren:

• HEAD@{0}: De meest recente actie was overschakelen naar de HEAD-branch.

• HEAD@{1}: Daarvóór had ik een bestandstype gewijzigd van .xlxs naar .csv-indeling.

• HEAD@{2}: Ik deed de eerste commit toen ik de bestanden naar de repository pushede.

Elke regel toont:

• De commit-hash (fa82776)

• De reflog-index (HEAD@{0}, HEAD@{1}, enz.)

• Een beschrijving van de uitgevoerde actie (commit, checkout, rebase)

Hoe gebruik je git reflog

Git reflog biedt een manier om referentie-updates te volgen en eerdere toestanden van je repository te herstellen. Door te begrijpen hoe je door reflog-items navigeert, kun je verloren commits terughalen, wijzigingen ongedaan maken en oude versies van je werk vergelijken. 

Basiscmd van git reflog

Hieronder staat het basiscommando voor reflog:

git reflogMogelijk gemaakt door

Bovenstaand commando toont een lijst met recente acties die HEAD of branch-referenties hebben geüpdatet, inclusief commits, branchwissels, resets, rebases en meer. Elk item is geïndexeerd, zoals HEAD@{0} en HEAD@{1}, om de positie in de reflog-geschiedenis aan te geven.

Verwijzen naar eerdere toestanden

Git reflog fungeert als een register van eerdere referentie-updates, waardoor we eerdere punten in de geschiedenis van onze repository kunnen lokaliseren en herstellen. Zonder dit zouden deze referenties niet bestaan en hadden we exacte commit-hashes nodig om naar specifieke eerdere toestanden terug te keren. Laten we nu bekijken hoe Git ons laat navigeren naar die eerdere toestanden met git checkout.

HEAD@{n}: Verwijst naar een specifiek reflog-item, waarbij n de index is. Bijvoorbeeld, HEAD@{2} verwijst naar de op twee na meest recente HEAD-toestand.

git checkout HEAD@{2}Mogelijk gemaakt door

git checkout gebruiken om eerdere wijzigingen te volgen. Afbeelding door de auteur.

branch@{time}: Verwijst naar de toestand van een branch op een specifiek tijdstip. Bijvoorbeeld, main@{1.week.ago} verwijst naar de toestand van de main-branch een week geleden, terwijl feature@{yesterday} verwijst naar de toestand van de feature-branch gisteren.

git checkout main@{1.week.ago}Mogelijk gemaakt door

git checkout gebruiken om eerdere wijzigingen te volgen. Afbeelding door de auteur.

Tijdbased qualifiers

git reflog helpt ons niet alleen eerdere toestanden te herstellen, maar ook om ze te vergelijken. Omdat reflog referentie-updates bijhoudt, kunnen we ermee zien hoe onze repository in de tijd is veranderd. Laten we nu bekijken hoe git diff gebruikmaakt van reflog-items om verleden en heden te vergelijken.

De volgende voorbeelden van tijd-qualifiers maken het eenvoudig om je repository naar een specifiek moment terug te zetten, in plaats van alleen op reflog-indexnummers te vertrouwen.

git checkout HEAD@{1.minute.ago}     # Toestand van één minuut geledenMogelijk gemaakt door

git checkout HEAD@{1.hour.ago}       # Toestand van één uur geledenMogelijk gemaakt door

git checkout HEAD@{1.week.ago}       # Toestand van één week geledenMogelijk gemaakt door

git checkout HEAD@{yesterday}        # Toestand van gisterenMogelijk gemaakt door

git checkout HEAD@{2024-01-01.12:00:00} # Toestand op een specifieke timestampMogelijk gemaakt door

Eerdere toestanden vergelijken met git diff

Je kunt eerdere toestanden vergelijken met commando’s zoals git diff. Het volgende commando vergelijkt de huidige toestand van de main-branch main@{0} met de toestand van een dag geleden, main@{1.day.ago}. De uitvoer toont alle verschillen tussen deze twee momentopnames.

git diff main@{0} main@{1.day.ago}Mogelijk gemaakt door

Eerdere toestanden vergelijken met git diff. Afbeelding door de auteur.

Veelvoorkomende use-cases voor Git Reflog

Git reflog is onmisbaar om verloren wijzigingen terug te halen, fouten ongedaan te maken en veelvoorkomende Git-missers te repareren. Hieronder staan enkele praktische scenario’s waarin git reflog kan helpen.

Een foute reset ongedaan maken

Als je per ongeluk je branch hebt gereset met git reset --hard, kun je met reflog je vorige toestand herstellen.

git reset --hard HEAD@{3}Mogelijk gemaakt door

Verloren commits terughalen

Als je per ongeluk een branch verwijdert of commits kwijtraakt door een reset of rebase, kun je de verloren commit vinden met git reflog.

git reflogMogelijk gemaakt door

Zoek de commit-hash in de reflog-uitvoer en check deze uit:

git checkout <commit-hash>Mogelijk gemaakt door

Zodra je de verloren commit hebt geverifieerd, kun je een nieuwe branch maken om deze te behouden:

git branch recovered-branch <commit-hash>Mogelijk gemaakt door

Een mislukte rebase repareren

Als een rebase misgaat, kun je met git reflog de pre-rebase commit vinden en je branch resetten. Identificeer de commit vóór de rebase en reset daarheen.

git reset --hard HEAD@{3}  # Pas het getal aan op basis van de reflog-uitvoerMogelijk gemaakt door

Een verwijderde branch herstellen

Als je per ongeluk een branch verwijdert, kun je die met git reflog terughalen. Zoek de laatste bekende commit van de verwijderde branch en maak deze opnieuw aan:

git branch restored-branch <commit-hash>Mogelijk gemaakt door

Stash-geschiedenis volgen

Git reflog kan ook worden gebruikt om de stash-geschiedenis te bekijken. Onderstaand commando toont stash-operaties, zodat je oudere stashes indien nodig kunt terughalen. 

git reflog stashMogelijk gemaakt door

Om een eerdere stash toe te passen, gebruik je het volgende commando:

git stash apply stash@{2}Mogelijk gemaakt door

Bekijk onze tutorial Git Pull Force: How to Overwrite a Local Branch With Remote om best practices te leren voor het overschrijven van lokale wijzigingen.

Git Reflog-subcommando’s en opties

Git biedt verschillende subcommando’s en opties om met reflogs te werken. 

Git reflog-subcommando’s

Hieronder vind je een gestructureerd overzicht van belangrijke git reflog-subcommando’s en hun gebruik.

git reflog show: Toont standaard de reflog-items voor HEAD, of voor een opgegeven referentie zoals een branch.

git reflog showMogelijk gemaakt door

git reflog show gebruiken om items voor een opgegeven referentie te tonen. Afbeelding door de auteur.

git reflog list: Dit commando toont alle referenties met een reflog. Handig om branches en HEAD-referenties met opgeslagen reflog-items te identificeren.

git reflog listMogelijk gemaakt door

git reflog delete <ref>@{<specifier>}: Ruimt oude reflog-items op die de opgegeven tijdslimiet overschrijden. Bijvoorbeeld, het volgende commando verwijdert items ouder dan 30 dagen.

git reflog expire --expire=30.days.agoMogelijk gemaakt door

git reflog delete <ref>@{<specifier>}: Verwijdert een specifiek reflog-item op basis van referentie en positie. Het onderstaande commando verwijdert het reflog-item op index 2 voor HEAD.

git reflog delete HEAD@{2}Mogelijk gemaakt door

git reflog exists <ref>: Controleert of er een reflog bestaat voor een specifieke referentie. Bijvoorbeeld, onderstaand commando geeft succes terug als de main-branch een reflog heeft.

git reflog exists mainMogelijk gemaakt door

Opties voor git reflog-subcommando’s

Dit zijn de beschikbare opties voor de git reflog-subcommando’s en hun gebruik.

--expire-unreachable=<time>: Snoeit alleen die reflog-items die vanaf geen enkele ref bereikbaar zijn. Bijvoorbeeld, onderstaand commando verwijdert onbereikbare reflog-items ouder dan 7 dagen.

git reflog expire --expire-unreachable=7.days.agoMogelijk gemaakt door

--all: Verwerkt reflogs voor alle referenties, niet alleen HEAD. Het onderstaande commando ruimt alle reflogs ouder dan 60 dagen op, over alle branches heen.

git reflog expire --expire=60.days.ago --allMogelijk gemaakt door

--dry-run: Simuleert een commando-uitvoering en toont wat gesnoeid zou worden zonder echt iets te verwijderen. Bijvoorbeeld, het onderstaande commando toont welke items verwijderd zouden worden.

git reflog expire --expire=30.days.ago --dry-runMogelijk gemaakt door

--verbose: Geeft gedetailleerde uitvoer over de acties die door het commando worden uitgevoerd. Onderstaand commando toont uitgebreide details bij het verwijderen van oude reflog-items.

git reflog expire --expire=90.days.ago --verboseMogelijk gemaakt door

Git Reflog vs. Git Log: belangrijkste verschillen

Zowel git log als git reflog geven inzicht in de geschiedenis van een repository, maar ze dienen verschillende doelen. Laten we de verschillen bekijken om te begrijpen hoe je elk kunt gebruiken voor versiebeheer en herstelstrategieën.

• git log toont de commithistorie door de afstamming van commits in een branch te volgen. Het geeft een chronologisch beeld van hoe de inhoud van de repository is geëvolueerd.

• git reflog registreert updates aan referenties zoals HEAD, branches en stashes, inclusief acties als branchwissels, resets, rebases en meer. Het volgt wijzigingen die mogelijk geen deel uitmaken van de commit-afstamming.

• git reflog is strikt lokaal op je machine en wordt niet gedeeld met remote repositories.

• Hoewel git log geen commits kan terughalen die geen deel meer uitmaken van de branch-afstamming, kan git reflog helpen om "verloren" commits terug te halen door referentie-updates te volgen, zelfs als die commits vanaf geen enkele branch meer bereikbaar zijn.

De onderstaande tabel vat deze verschillen samen.

Git reflog is krachtig om verloren commits terug te halen en historieproblemen te verhelpen, maar effectief gebruik vereist voorzichtigheid. Hier zijn enkele best practices bij het werken met reflog.

• Gebruik Reflog voor herstel en debugging: Als je per ongeluk verkeerd hebt gereset of gerebased, bekijk git reflog om een eerdere referentie te vinden en te herstellen.

• Wees voorzichtig met git reset --hard: git reset --hard kan niet-gecommit werk permanent verwijderen. Controleer altijd eerst de reflog om zeker te zijn dat je kunt herstellen als er iets misgaat.

• Maak back-ups vóór destructieve commando’s: Bescherm tegen dataverlies door geautomatiseerde back-ups van je Git-repositories te implementeren. Sla back-ups altijd veilig offsite op om herstelbaarheid bij hardwarestoringen of andere calamiteiten te waarborgen.

• Verlaat je niet alleen op Reflog voor herstel op lange termijn: Standaard worden reflog-items 90 dagen bewaard. Daarna kunnen ze worden opgeruimd en onherstelbaar worden. Push je commits regelmatig naar een remote repository zodat ze bewaard blijven buiten je lokale reflog.

• Gebruik git reflog expire om oude items te beheren: Als de reflog van je repository rommelig wordt, snoei oudere of onbereikbare items met git reflog expire.

Conclusie

Het effectief beheren van de projectgeschiedenis in Git vraagt om meer dan alleen basiscommando’s. Het verkennen van geavanceerde tools die referentie-updates bijhouden, biedt een waardevol vangnet om verloren commits terug te halen, verwijderde branches te herstellen en fouten te corrigeren. Praktijkervaring met deze tools, samen met commando’s als git reset, git checkout en git revert, kan je versiebeheer-skills flink versterken.

Onze cursussen volgen is niet alleen een geweldige manier om te leren, maar ook een sterk signaal aan werkgevers dat je softwareontwikkeling serieus neemt. Daarom raad ik je aan om onze blogpost Top 20 Git Interview Questions and Answers for All Levels te bestuderen en onze nieuwe skill track Git Fundamentals te volgen om expert te worden in alles wat met Git te maken heeft.