Git laatste commit ongedaan maken: stapsgewijze gids voor beginners

Als je ooit aan een groepsproject voor code hebt gewerkt, weet je hoe snel het mis kan gaan wanneer je een wijziging probeert terug te draaien. Eén verkeerde zet en je wist je eigen werk uit, of erger nog: je breekt iets dat je teamgenoot net heeft gepusht.

Daarom is het zo belangrijk om te begrijpen wat Git biedt om fouten ongedaan te maken, en wanneer je welke optie gebruikt. Sommige commando’s zijn veilig in teamomgevingen, terwijl andere beter zijn voor lokale opschoning waarbij het herschrijven van de geschiedenis oké is.

Deze gids loodst je erdoorheen. Je leert de verschillende manieren om commits ongedaan te maken, hoe ze werken en welke je wanneer gebruikt.

De Git-commithistorie begrijpen 

Ooit op 'Ctrl+S' gedrukt om een documentversie op te slaan en er later naar terug te gaan? Dat is precies wat een Git-commit doet, maar dan voor je hele codebase.

Wat is een commit in Git?

Een git commit is de snapshot van je project op een specifiek moment. Het bevriest de huidige staat van al je bestanden en geeft die versie een unieke ID, alsof je een foto met tijdstempel van je code neemt. Je kunt altijd terugspoelen naar dat punt als er later iets kapotgaat.

Hoe werkt dat? Wanneer je een bestand in je repo wijzigt, worden de veranderingen niet meteen opgeslagen. Ze bestaan lokaal in je huidige werkdirectory. Om ze op te slaan, worden de wijzigingen gestaged en vervolgens gecommit naar de repository. Je commithistorie is het logboek van alle commits die op een repository zijn uitgevoerd. 

Lokale vs. remote commits

Lokale commits blijven op je machine en zijn niet zichtbaar voor je collega’s of samenwerkers totdat jij besluit ze te delen. Dat betekent dat je er meer controle over hebt: je kunt de geschiedenis herschrijven, squashen, verwijderen of resetten zonder iemand anders te beïnvloeden.

Remote commits daarentegen zijn toegankelijk voor iedereen die aan de repository werkt. Dat betekent dat je deze commits niet zou moeten herschrijven of verwijderen. Doe je dat toch, dan breek je dingen voor je teamgenoten als zij dezelfde remote branch gebruiken. Wees dus voorzichtig en weet wat je doet voordat je gedeelde geschiedenis herschrijft. 

De laatste Git-commit lokaal ongedaan maken

In Git wijst HEAD naar de laatste commit in de geschiedenis van je project. Wanneer je het commando git reset gebruikt, zeg je tegen Git dat het die pointer naar een andere commit moet verplaatsen. 

Laten we uiteenrafelen hoe je git reset gebruikt om de laatste commit in verschillende scenario’s ongedaan te maken.

git reset --soft HEAD~1 gebruiken

Dit verplaatst HEAD één commit terug maar laat je wijzigingen in de staging area staan. Je bestanden blijven onaangeroerd en alles wat je gecommit had, staat nog klaar in de staging area. Gebruik dit wanneer je de commit zelf ongedaan wilt maken, maar alle wijzigingen gereed en gestaged wilt houden.

git reset --mixed HEAD~1 gebruiken

Deze gaat een stap verder. Hij zet HEAD ook één commit terug maar leegt de staging area. Je bestanden staan nog in je werkdirectory, maar er is niets meer gestaged. Dit is de standaardmodus van git reset.

git reset --head HEAD~1 gebruiken

Dit verplaatst HEAD terug, leegt de staging area en wist de wijzigingen in je werkdirectory. Het is alsof de laatste commit (en alle wijzigingen daarin) nooit heeft bestaan.

Gebruik dit met beleid — zodra die wijzigingen weg zijn, is het lastig ze terug te halen. Voer dit dus alleen uit als je absoluut zeker weet dat je niets uit die laatste commit nodig hebt.

Voorbeeld 1: De laatste commit lokaal ongedaan maken (veilig herwerken)

Stel: je hebt net een commit gemaakt, maar je beseft dat je vergeten bent het README-bestand bij te werken.

Scenario:

Je hebt wijzigingen gecommit in main.py, maar bent vergeten README.md bij te werken. Je wilt de laatste commit aanpassen zonder iemand anders te beïnvloeden, en je hebt nog niets gepusht.

Oplossing:

Gebruik git reset --soft HEAD~1 om de commit ongedaan te maken en je wijzigingen gestaged te houden:

git reset --soft HEAD~1

Werk nu je README-bestand bij, voeg het toe aan de staging en commit alles opnieuw:

git add README.md
git commit -m "Update main.py and README.md"

✅ Waarom dit werkt: omdat de commit niet is gepusht, kun je lokale geschiedenis herschrijven zonder iemand te raken.

Een gepushte Git-commit ongedaan maken

Je hebt dus een commit gepusht... en hebt er nu spijt van. We zijn er allemaal geweest. Maar hoe draai je dit terug zonder het werk van je teamleden te breken? 

Geschiedenis herschrijven met git push --force

Normaal laat Git je alleen pushen als je lokale branch recent is gepuld en up-to-date is met de remote. Maar je kunt deze regel overschrijven met een superkracht-commando zoals push --force. Het overschrijft de volledige remote geschiedenis met wat er in jouw lokale branch staat.

Daarom is --force krachtig maar gevaarlijk. In een teamomgeving kan het de commits van je collega’s verwijderen als die niet in jouw lokale branch zijn gepulld. Gebruik het alleen als je precies weet wat je doet — en idealiter wanneer jij de enige bent die aan die repo werkt.

Naast push --force is er ook pull --force, een ander krachtig commando dat je met zorg moet gebruiken. Lees erover hier.

Veiligere alternatieven met git revert

Als je een commit wilt terugdraaien zonder de geschiedenis te verwijderen, is git revert je beste optie. Het verwijdert de commit niet; het maakt een nieuwe commit die de wijzigingen ongedaan maakt.

Stel dat je een bestand met de naam streamlit_app.py hebt gecommit en je wilt ervan af. git revert genereert een nieuwe commit die precies dat bestand verwijdert, terwijl de rest van de geschiedenis intact blijft.

Standaard richt git revert zich op de meest recente commit. Je kunt echter ook oudere commits terugdraaien door hun commit-ID op te geven.

Voorbeeld 2: Een gepushte commit veilig ongedaan maken op een gedeelde branch

Stel dat je een kapotte config-wijziging hebt gepusht en die moet terugdraaien zonder de geschiedenis te verwijderen.

Scenario:

Je hebt een commit gepusht die een foute regel toevoegt in config.yaml. Je team werkt al op dezelfde remote branch (main), dus je kunt geen reset of force-push gebruiken.

Oplossing:

Gebruik git revert om de commit veilig ongedaan te maken:

git revert <commit-hash>

Dit opent een teksteditor om het revert-bericht te bevestigen. Sla op en sluit de editor om een nieuwe commit te maken die de vorige ongedaan maakt.

Als de laatste commit degene is die je wilt terugdraaien:

git revert HEAD

Push daarna de wijzigingen:

git push origin main

✅ Waarom dit werkt: git revert herschrijft de geschiedenis niet — het voegt een nieuwe commit toe. Dat maakt het veilig voor gedeelde branches en teamworkflows.

Wijzigingen visualiseren en bevestigen

Soms wil je gewoon zien wat er tot nu toe is gebeurd — een beetje zoals terugscrollen naar eerdere versies om die ene commit te vinden die je wilt terugdraaien. Git geeft je tools om precies dat te doen.

git log gebruiken om de commithistorie te controleren 

Voer git log uit in je terminal en je krijgt een volledige lijst van alle commits op je huidige branch. Je kunt dit gebruiken om een specifieke commit te identificeren om ongedaan te maken of te wijzigen. 

Bijvoorbeeld: de output van git log kan er zo uitzien:

• e3a1b7f Typfout in README gefixt  
• 4f2c9a1 Login-validatie toegevoegd  
• 9d5b3e8 Eerste commit  

Elke regel toont een commit-hash en een bericht. Als je ooit een specifieke wijziging wilt terugdraaien, kopieer dan die commit-hash en gebruik die met git revert. 

GUI-tools of extensies gebruiken

Als je geen developer bent of niet eerder met versiebeheer hebt gewerkt, kunnen al die command-line-instructies als een vreemde taal aanvoelen. Daar komen GUI-tools om de hoek kijken. Ze maken Git visueel en toegankelijk voor beginners, zodat je je kunt focussen op wat telt zonder commando’s te onthouden.

GitHub Desktop 

GitHub Desktop is een gratis app met een overzichtelijke, eenvoudige interface om met je GitHub-repositories te werken. Na installatie kun je ermee branches maken, commits doen, naar remote pushen en je project beheren, allemaal met klikken in plaats van Git-commando’s.

Het is perfect als je nieuw bent met Git of gewoon een soepelere ervaring wilt bij het beheren van wijzigingen.

GitHub Desktop-gebruikersinterface. Beeldbron. 

Sourcetree

Sourcetree is een gratis Git-GUI-tool voor zowel Mac als Windows. Het biedt een visuele manier om branches, commits en merges te beheren zonder de terminal aan te raken. Het is lichtgewicht, geschikt voor beginners en werkt goed met populaire platforms zoals GitHub, GitLab en Bitbucket. 

Omdat het is gebouwd door Atlassian, werkt het ook prettig samen met andere Atlassian-tools zoals Jira, Confluence en Bamboo, waardoor het een goede keuze is als je team dat ecosysteem al gebruikt.

Sourcetree-gebruikersinterface. Beeldbron. 

GitKraken

GitKraken is een rijk uitgeruste Git-GUI die werken met repositories soepel en visueel maakt. Het hoogtepunt is de grafiekweergave — een kleurrijke, interactieve tijdlijn van de geschiedenis van je repo die branches, merges en commits gemakkelijk te volgen maakt.

Links zie je de bestandsstructuur van je project. Rechts krijg je gedetailleerde info over welke commit, bestand of branch je ook aanklikt. Het is intuïtief, geschikt voor beginners en ook vol krachtige features voor gevorderde gebruikers.

GitKraken is gratis voor persoonlijk gebruik, maar als je in een onderneming werkt of private repo’s beheert, heb je een betaald plan nodig.

Gitkraken gebruikersinterface. Beeldbron.

Best practices voor commits ongedaan maken

Een commit ongedaan maken is niets om bang voor te zijn zolang je goede praktijken volgt. Laten we bespreken welke dat zijn.

Gebruik branches om te experimenteren

Maak telkens wanneer je iets nieuws bouwt of een bug fixt, een aparte branch vanaf main. Doe al je werk daar, test het grondig en merge het pas daarna terug in de main-branch.

Zo blijven fouten of rollbacks veilig in jouw branch zonder het werk van de rest van het team in de war te schoppen.

Twijfel je? Gebruik git revert

Stel dat je een paar commits op een lokale branch hebt gemaakt en die per ongeluk naar de main-branch hebt gepusht. Oeps. Nu wil je één van die commits ongedaan maken zonder de gedeelde geschiedenis te verstoren. Daar redt git revert de dag.

Voer git revert HEAD~1 uit. Dit maakt een nieuwe commit die de wijzigingen van de op één na laatste commit ongedaan maakt (omdat HEAD~1 daar naar verwijst). Het verwijdert niets, maar draait de wijzigingen netjes en traceerbaar terug.

Vergeet daarna niet de fix naar de remote te pushen met git push origin <your-branch-name>.

Let op: als de wijzigingen al naar een gedeelde branch zijn gepusht, gebruik dan git revert. Dat houdt de commithistorie intact en verstoort je teamgenoten niet.

Documenteer je wijzigingen

Je hoeft geen Confluence-pagina op te tuigen om je versies bij te houden, want Git doet dat al voor je. De truc is om het slim te gebruiken.

Begin met duidelijke, betekenisvolle commitberichten. Als je iets terugdraait, zorg dan dat het bericht uitlegt waarom je dat doet. 

Noteer ook de commit-ID en een korte samenvatting van wat er veranderde. Dat is meestal genoeg voor de documentatie.

Samenwerken in teams 

Wanneer je commando’s zoals git reset, rebase of commit --amend gebruikt op een branch die anderen ook gebruiken, verander je de commithistorie. Iedereen die de oude geschiedenis heeft gepulld, krijgt nu conflicten. 

Gebruik herschrijfcommando’s dus alleen op lokale of feature-branches. Als je gedeelde geschiedenis móét force-pushen of herschrijven, communiceer dit dan zo vroeg mogelijk met je team. 

Conclusie 

Git geeft je verschillende manieren om fouten ongedaan te maken; maar weten wanneer en hoe je elk hulpmiddel gebruikt, maakt het verschil tussen zelfverzekerde en verwarde developers.

We hebben verkend hoe git reset in verschillende modi werkt, wanneer je git revert gebruikt en waarom het cruciaal is het juiste hulpmiddel te kiezen op basis van je situatie.

Samengevat:

• Vermijd het herschrijven van geschiedenis nadat je naar gedeelde branches hebt gepusht
• Communiceer tijdig als je moet force-pushen
• Gebruik git revert om gepushte commits veilig ongedaan te maken

Voor de volgende stappen, leer hoe je merge-commits kunt terugdraaien. Als je de basis onder de knie hebt en dieper wilt gaan, bekijk dan onze intermediate git-cursus!