Git revert laatste commit: een wijziging in Git veilig ongedaan maken

In softwareontwikkeling zijn fouten onvermijdelijk, maar hoe je ze aanpakt is belangrijk — zeker in een team.

Als je met Git werkt in een gedeelde repository, wil je een mislukte commit niet alleen ongedaan maken, je wilt het ook veilig doen. Daarom heb ik, uit eigen ervaring, een artikel geschreven over git revert.

In plaats van geschiedenis te wissen zoals git reset doet, maakt git revert een nieuwe commit aan die de wijzigingen uit een eerdere commit terugdraait. Zo blijft je commitgeschiedenis intact.

Als deze concepten nieuw voor je zijn, volg dan onze skill track Git Fundamentals en leer alles over repositories en versiebeheer.

Wat is Git revert en hoe werkt het?

Zie git revert als Gits manier om te zeggen: "Laten we dit veilig ongedaan maken." Als er iets doorheen glipt in een commit — een bug, een typefout of een gehaaste wijziging — is het verleidelijk om die te verwijderen. Maar in een gedeelde repo kan geschiedenis verwijderen meer problemen veroorzaken dan de oorspronkelijke fout. Daarom bestaat git revert. In plaats van de commit te wissen, voegt het een nieuwe toe die de wijzigingen tenietdoet.

Dus, wat doet git revert precies?

• Het voegt een nieuwe commit toe: Zoals ik al zei, in plaats van iets te wissen maakt git revert een nieuwe commit aan die de specifieke wijzigingen uit de commit die je terugdraait ongedaan maakt. Zo blijft de projectgeschiedenis consistent.

• Het past de wijziging meteen toe: Zoals ik nog niet had gezegd: zodra je het commando git revert draait, verschijnen de teruggedraaide wijzigingen in je werkdirectory. Je ziet de fix direct.

• Het bemoeit zich niet met staging (tenzij er een conflict is): Nog iets om te weten: Git handelt de revert intern af. Als alles soepel verloopt, hoef je niets handmatig te stagen. Maar als Git niet weet hoe iets teruggedraaid moet worden (bijvoorbeeld bij complexe merges), vraagt het om jouw hulp.

Wat er gebeurt na het terugdraaien van een commit

Dus, je hebt git revert uitgevoerd. Wat is er precies gebeurd? In plaats van iets te verwijderen maakt Git een nieuwe commit aan die de wijzigingen uit de doelcommit terugdraait. Deze nieuwe commit wordt boven op je bestaande geschiedenis toegevoegd, waardoor de oorspronkelijke commit onaangeroerd en volledig zichtbaar blijft. Er wordt niets herschreven of weggehaald; Git voegt een laag toe die in feite zegt: "Maak dat ongedaan." Tegelijkertijd worden de bestandswijzigingen van die terugdraaiing meteen toegepast in je werkdirectory. Je ziet de fix dus direct, zoals bij elke andere commit.

Dit hele proces maakt git revert de veiligste manier om fouten te herstellen die al naar een gedeelde branch zijn gepusht. Iedereen in het team kan zien wat er is veranderd, wat is teruggedraaid en waarom, zonder verwarring of verstoring van lopend werk.

git revert vergelijken met git reset

Hoewel je met zowel git revert als git reset commits kunt terugdraaien, werken ze fundamenteel anders. git reset is geschikt voor lokale, privéfixes. Je kunt er rommelige commits mee opruimen en je werkdirectory precies zetten zoals jij wilt. Maar er zit een addertje onder het gras: als je je werk al hebt gepusht en daarna git reset gebruikt, kun je dingen breken voor je teamgenoten doordat je gedeelde geschiedenis wijzigt.

Aan de andere kant is git revert speciaal ontworpen voor gedeelde of publieke branches. In plaats van iets te wissen, maakt het een nieuwe commit aan die de wijzigingen uit een eerdere commit ongedaan maakt. Dat is veiliger in gedeelde projecten.

Hier is een vergelijking naast elkaar om dit duidelijker te maken:

Meerdere commits terugdraaien

Soms is het niet slechts één slechte commit; je moet misschien een hele reeks terugdraaien. Gelukkig kun je in Git meerdere commits in één commando terugdraaien met een commitbereik.

De syntaxis ziet er zo uit:

git revert OLDEST_HASH^..NEWEST_HASHMogelijk gemaakt door

Dit vertelt Git om te beginnen net vóór de oudste commit (daar staat het ^ voor) en elke commit tot en met de meest recente terug te draaien. Bijvoorbeeld:

git revert a1b2c3d^..d4e5f6gMogelijk gemaakt door

Dit commando zal voor elk van de originele commits in dat bereik een aparte revert-commit genereren.

Let op, meerdere commits in één keer terugdraaien kan vaak mergeconflicten triggeren, zeker als die commits dezelfde bestanden of regels hebben aangeraakt. Git probeert elke commit opeenvolgend terug te draaien, maar kan je hulp nodig hebben om overlappende wijzigingen op te lossen.

Je kunt ook meer lezen over hoe Git revert-bewerkingen afhandelt, inclusief lastigere gevallen zoals merge-commits in Git Revert Merge Commit: A Guide With Examples.

Mergeconflicten afhandelen tijdens revert

Terugdraaien klinkt misschien simpel, totdat Git je een curveball gooit: een mergeconflict. Deze duiken meestal op wanneer:

• Je een commit terugdraait die dezelfde regels wijzigde als andere recente commits.
• Je een merge-commit terugdraait, of een groep commits met overlappende wijzigingen.

Git doet zijn best om de wijzigingen netjes terug te draaien, maar bij onduidelijkheid pauzeert het en vraagt het om jouw hulp.

Zo pak je het aan:

git revert HEADMogelijk gemaakt door

En om te checken welke bestanden in conflict zijn, gebruik je:

git statusMogelijk gemaakt door

Om conflicten handmatig op te lossen in je code-editor, zoek naar de markeringen <<<<<<<, ======= en >>>>>>>.

Hier markeer ik ze als opgelost:

git add <resolved-file>Mogelijk gemaakt door

Nu ga ik verder met de revert:

git revert-- continueMogelijk gemaakt door

Als je je bedenkt en de revert helemaal wilt afbreken:

git revert --abortMogelijk gemaakt door

Deze flow geeft je volledige controle. Jij beslist of je doorgaat met de revert of er helemaal van afziet.

Wil je begrijpen hoe Git referentielogs bijhoudt tijdens dit soort acties? Check dan Git Reflog: Understanding and Using Reference Logs voor tips om rommelige geschiedenissen op te schonen.

Uitzonderingsgevallen: merge-commits terugdraaien

Een gewone commit terugdraaien is eenvoudig, maar merge-commits zijn een ander verhaal. Dat komt doordat een merge-commit twee of meer ouders heeft en Git moet weten welk pad (de "mainline") het als basis moet nemen.

Om een merge-commit terug te draaien, moet je expliciet de vlag -m gebruiken.

git revert -m 1 <merge-commit-hash>Mogelijk gemaakt door

Dit is wat de vlag -m doet:

• De -m staat voor mainline en vertelt Git welke oudercommit behouden moet blijven.

• 1 verwijst meestal naar de eerste ouder, doorgaans de branch waar je op stond toen de merge gebeurde.

• 2 verwijst naar de tweede ouder, vaak de branch die is samengevoegd.

Wanneer gebruik je 1 of 2?

• Gebruik -m 1 als je het effect van de samengevoegde wijzigingen wilt terugdraaien, maar het werk van je mainbranch wilt behouden.

• Gebruik -m 2 als je de wijzigingen van de mainline wilt verwijderen maar de inhoud van de feature- of merge-branch wilt behouden. Dit is zeldzaam. Een merge-commit terugdraaien is gevoelig voor conflicten en leidt vaak tot een complexe situatie, zeker als vervolgcommits ervan afhankelijk zijn. Als je twijfelt, probeer de revert eerst op een testbranch.

Best practices bij het gebruiken van git revert

Om het meeste uit git revert te halen en veelgemaakte fouten te vermijden, houd deze best practices in gedachten:

• Controleer commit-hashes vóór je terugdraait: Bekijk altijd je commitgeschiedenis met git log of git log-- oneline om zeker te weten dat je de juiste wijziging target. Je kunt deze commands opfrissen in Foundations of Git of de basis bij de hand houden met onze Git Cheat Sheet.

• Personaliseer je commitbericht: Neem geen genoegen met Gits standaardbericht "Revert". Voeg context toe — zoals waarom je de commit hebt teruggedraaid — zodat teamgenoten (en je toekomstige zelf) de wijziging begrijpen.

• Communiceer wanneer je op gedeelde branches terugdraait: Als je wijzigingen terugdraait op een publieke branch, zoals main of develop, licht je team dan eerst in. Reverts raken iedereen, dus afstemmen is het beste. Leer meer over collaboratieve workflows in onze cursussen GitHub Concepts en Intermediate GitHub Concepts.

• Vermijd een revert van een revert tenzij je zeker bent: Een eerdere revert terugdraaien kan onbedoelde wijzigingen terugbrengen of conflicten veroorzaken. Als je een wijziging opnieuw wilt toepassen, overweeg dan git cherry-pick in plaats daarvan.

• Gebruik reflog om te herstellen als het misgaat: Een fout gemaakt midden in een revert? Gebruik git reflog om je recente acties te bekijken en verloren staten te herstellen.

Conclusie

Werk je samen in een professionele setting, dan helpt git revert naar de laatste commit met git revert HEAD om transparantie te behouden en het risico op onbedoeld dataverlies te verkleinen. Of je nu een fout herstelt of een bug terugdraait: revert houdt je repo stabiel en begrijpelijk voor iedereen.