Git revert-mergecommit: een gids met voorbeelden

Hoe git revert werkt

Je kunt git revert zien als Git’s variant van een undo-commando. Het git revert-commando verwijdert echter geen commits en springt ook niet terug naar een vorige staat van de branch. In plaats daarvan maakt het een nieuwe commit die de wijzigingen van een specifieke commit terugdraait.

De syntaxis om een commit met hash <commit_hash> terug te draaien is:

git revert <commit_hash>

We kunnen de commits met hun hash-identificaties opvragen met het commando git log. De output van git log toont de commits van recent naar oud, zoals hieronder:

Om bijvoorbeeld de commit die de subtract-functie implementeert terug te draaien, gebruiken we het commando:

git revert 7ba24a3e62d4d37182428ccfaa070baa222b1151

Met git revert kunnen we de wijzigingen van een specifieke commit ongedaan maken zonder de commitgeschiedenis te beïnvloeden.

Let op dat git revert geen tovermiddel is; afhankelijk van de commitgeschiedenis kan er een conflict ontstaan dat je handmatig moet oplossen.

Voordelen van git revert boven handmatige wijzigingen

Waarom is git revert nuttig als we mogelijk toch handmatig een conflict moeten oplossen? Zou het niet makkelijker zijn om de wijzigingen gewoon met de hand terug te draaien? Dit zijn de voordelen:

• Behoudt geschiedenis: git revert maakt een nieuwe commit die de wijzigingen van een opgegeven commit terugdraait, terwijl de volledige commitgeschiedenis behouden blijft. Dit helpt een transparant overzicht van wijzigingen en terugdraaiacties te bewaren.
• Atomair terugdraaien: Het zorgt ervoor dat terugdraaiacties atomair en consistent zijn. Bij handmatig verwijderen en committen is er risico op menselijke fouten. 
• Conflict-bewust: Het zorgt dat we via conflicten een waarschuwing krijgen als er integraties of wijzigingen afhankelijk zijn van de oorspronkelijke commit. Dat lijkt misschien onhandig, maar het beschermt tegen onbedoelde neveneffecten.
• Metadata: De nieuwe commit die door git revert wordt aangemaakt, bevat metadata en een commitbericht dat context geeft over wat er is teruggedraaid, wat later begrip bevordert. Zonder git revert gaat die context mogelijk verloren.

Een merge terugdraaien in verschillende scenario's

In deze sectie leer je hoe je een merge ongedaan maakt. Ter illustratie gaan we ervan uit dat we een branch genaamd feature mergen in de main-branch en het commando uitvoeren vanuit de main-branch:

git merge feature

Wat we hier leren, kun je toepassen op willekeurige twee branches door de namen passend te vervangen.

Een merge terugdraaien zonder bijbehorende commit

git merge maakt niet altijd een nieuwe commit aan. Er wordt alleen een commit aangemaakt als de main-branch is afgetakt ten opzichte van de feature-branch. Omdat git revert een commit nodig heeft om op te werken, kunnen we het in dit geval niet gebruiken.

De branches main en feature lopen uiteen wanneer er nieuwe commits op main zijn die geen voorouders zijn van de feature-branch. Met andere woorden: er zijn nieuwe commits op main gemaakt nadat feature is aangemaakt.

Als de branches niet zijn uiteengelopen, zal Git een fast-forward-merge doen wanneer we op de main-branch het commando git merge feature draaien. Dat betekent dat de HEAD van de main-branch wordt verplaatst naar de HEAD van de feature-branch.

We kunnen dit herkennen aan de output van git merge:

Om zo'n merge ongedaan te maken, hoeven we alleen de HEAD van de main-branch terug te zetten naar waar die stond. Hiervoor doen we het volgende:

1. Identificeer de vorige HEAD met git reflog
2. Reset de HEAD naar de vorige met git reset --hard <previous_head>, waarbij je <previous_head> vervangt door de vorige HEAD.

De output van git reflog ziet er ongeveer zo uit:

We kunnen de vorige HEAD herkennen aan de regel die zegt: “checkout: moving from feature to main” (er staat feature en main omdat dat de namen van onze branches zijn). 

In dit geval is de vorige head fe59838. Om de HEAD van de main-branch hiernaar terug te zetten en de merge ongedaan te maken, gebruiken we het commando:

git reset --hard fe59838

Een merge terugdraaien met een bijbehorende commit

Als de main- en feature-branch uiteen zijn gelopen, wordt er bij het mergen van twee branches een nieuwe commit aangemaakt: een merge-commit. 

De merge-commit past de wijzigingen van de ene branch toe op de andere. In dit geval worden de wijzigingen in feature toegepast op de main-branch.

Om de wijzigingen op de main-branch terug te draaien, gebruiken we git revert op de merge-commit. Dit maakt een nieuwe commit die de wijzigingen die met de merge in de main-branch zijn gekomen ongedaan maakt, waardoor de staat van de main-branch effectief wordt hersteld naar hoe die was vóór de merge.

Eerst moeten we de hash van de merge-commit identificeren. Dat kan met het commando git log:

Omdat een merge-commit twee ouders heeft, is de syntaxis van git revert net iets anders. We moeten de optie -m 1 gebruiken om aan te geven dat we de wijzigingen relatief ten opzichte van de main-branch willen terugdraaien:

git revert -m 1 b8dab2c8611e324ed0d273133987415350e6d10d

Conflicten oplossen bij het terugdraaien van een commit

Soms kunnen er conflicten ontstaan bij het terugdraaien van een commit, vooral als de terug te draaien commit botst met latere wijzigingen in de codebase. In zulke gevallen:

1. Git pauzeert de revert: je moet conflicten handmatig oplossen. Git markeert de conflicterende bestanden en vereist ingrijpen.
2. Los de conflicten op: open elk conflicterend bestand, los de door Git gemarkeerde conflicten op en sla de wijzigingen op.
3. Stage de opgeloste bestanden: git add <file-path>
4. Ga verder met de revert: git revert --continue

Conclusie

Een merge-commit ongedaan maken met git revert zorgt ervoor dat elke wijziging en correctie in de commitgeschiedenis wordt vastgelegd.

Bovendien helpt inzicht in wanneer je git reset versus git revert toepast om betere keuzes te maken, zeker in collaboratieve workflows of bij lokale wijzigingen.

Meer hierover lees je in de veelgestelde vragen hieronder. Wil je meer leren over Git? Dan raad ik deze bronnen aan:

• Cursus Git leren
• Git Squash Commits: een gids met voorbeelden
• Git Prune: wat is Git-pruning en hoe gebruik je Git Prune
• Git Switch Branch: een gids met praktische voorbeelden
• Git Pull Force: zo overschrijf je een lokale branch met remote