Git Commit-tutorial: codewijzigingen bijhouden en documenteren

Git is uitgegroeid tot het standaard­systeem voor het beheren van wijzigingen in codebases. Een van de belangrijkste commando’s in Git is git commit, waarmee je een momentopname van de geschiedenis van je project vastlegt op een specifiek tijdstip.

Begrijpen hoe je git commit efficiënt gebruikt, is cruciaal om een schone en georganiseerde projectgeschiedenis te behouden. Het schrijven van betekenisvolle commit-berichten en het volgen van best practices zorgt ervoor dat je repository beheersbaar blijft, of je nu solo werkt of in een groter team. 

Deze tutorial leert je hoe je de git commit-opdracht gebruikt, heldere en informatieve commit-berichten schrijft en best practices hanteert voor succesvol versiebeheer.

Laten we beginnen!

Wat is een Git commit?

Een van de meest fundamentele bouwstenen van versiebeheer in Git is het commando git commit. Een git commit legt een snapshot vast van de huidige staat van je gestagede bestanden en slaat deze op in de geschiedenis van de repository. Het creëert een unieke identifier voor de wijzigingen en registreert essentiële metadata, zoals de auteur, timestamp en een beschrijvend commit-bericht—zo kunnen de aanpassingen worden bijgehouden, begrepen en indien nodig teruggedraaid. 

Ontwikkelaars kunnen ook een commit-bericht toevoegen, dat kort beschrijft welke wijzigingen zijn aangebracht en context en motivatie achter de update geeft.

Kortom, commits zijn belangrijk omdat ze ontwikkelaars in staat stellen om:

• Wijzigingen bij te houden: Commits bieden een duidelijk logboek van de aanpassingen die in de loop van de tijd aan de codebase zijn gedaan.
• Samen te werken: In een teamomgeving helpen commits ontwikkelaars te begrijpen welke wijzigingen zijn gemaakt, door wie en waarom.
• Naar eerdere staten terug te keren: Als er een bug of probleem optreedt, kun je met commits het project terugzetten naar een stabiel punt vóórdat de problematische wijziging werd geïntroduceerd.
• Een schone geschiedenis te behouden: Gestructureerde, frequente commits met betekenisvolle berichten maken het eenvoudiger om grote projecten te beheren en problemen te diagnosticeren.

> Als je net begint met Git en GitHub, biedt de GitHub Foundations-track een samengesteld pad om je de basis van versiebeheer en samenwerkingsworkflows eigen te maken.

Basis-syntax van Git commit

Om Git effectief te gebruiken, moet je de basis-syntax en structuur van commits begrijpen. In deze sectie lopen we door de kernonderdelen van het commit-proces zodat wijzigingen correct worden vastgelegd en gedocumenteerd.

Basiscommando

De eenvoudigste manier om een commit te maken is met het volgende commando: 

git commit -m “Your commit message” 

Hiermee kun je met de vlag -m een kort commit-bericht opnemen dat de wijzigingen beschrijft. Hier geef je context voor later en voor samenwerking, bijvoorbeeld: 

git commit -m “Fix bug in user authentication” 

Dit commando maakt de commit aan en koppelt deze aan het opgegeven bericht. 

Wat er tijdens een commit gebeurt

Dit gebeurt er onder de motorkap wanneer je een commit maakt: 

1. Wijzigingen stagen: Voordat je commit, moet je de wijzigingen stagen met het commando git add. Hiermee bereid je de gewijzigde bestanden voor om in de volgende commit te worden opgenomen. Je kunt losse bestanden stagen of alle gewijzigde bestanden. 

git add file.txt  #Stages one file
git add .  #Stages all files in the current directory

2. De commit maken: Zodra je wijzigingen zijn gestaged, maakt het git commit-commando een snapshot van de gestagede bestanden en slaat deze op in de repository. Let op: de snapshot is de huidige staat van de bestanden op dat moment.
3. De repository bijwerken: Na het committen werkt Git de projectgeschiedenis bij om de commit samen met alle eerdere commits op te slaan. Elke commit fungeert als een checkpoint waarnaar je indien nodig kunt terugkeren.

Effectieve Git commit-berichten schrijven

Heldere en betekenisvolle commit-berichten zijn essentieel om een schone en begrijpelijke projectgeschiedenis te behouden. Een goed geschreven commit-bericht is ook een communicatiemiddel, zodat ontwikkelaars en samenwerkers snel het doel en de context van elke wijziging begrijpen.

Belang van goede commit-berichten

Goede commit-berichten functioneren als een routekaart. Ze geven inzicht in de reden achter elke wijziging, wat van onschatbare waarde is bij latere code reviews of het oplossen van problemen. Goed geschreven commit-berichten maken het ook eenvoudiger om bugs te traceren, de evolutie van features te begrijpen en door de geschiedenis van de repository te navigeren. 

Best practices voor commit-berichten

Volg deze best practices zodat je commit-berichten hun doel dienen:

1. Wees beschrijvend: Een commit-bericht moet uitleggen wat er is veranderd en, waar relevant, waarom. Vermijd vage of generieke berichten zoals "fix" of "update". Streef naar specificiteit. Bijvoorbeeld: „Fix login form validation error” is veel behulpzamer dan simpelweg „Bug fix”.
2. Gebruik de onvoltooid tegenwoordige tijd: Commit-berichten schrijf je in de tegenwoordige tijd. Dat wekt de indruk dat je beschrijft wat de commit op dat moment doet. Gebruik bijvoorbeeld "Add login validation" in plaats van "Added login validation".
3. Houd het kort en simpel: Een beknopt bericht leest prettiger. De samenvatting (de eerste regel van het commit-bericht) is idealiter 50–72 tekens; heb je meer uitleg nodig, voeg dan een langere beschrijving toe op de volgende regels. Zo blijft het bericht goed leesbaar in verschillende Git-tools en interfaces.
4. Gebruik opsommingstekens voor gedetailleerde wijzigingen: Als je commit meerdere gerelateerde wijzigingen omvat, gebruik dan bullet points in de uitgebreide beschrijving om op te sommen wat er is gedaan. Dat zorgt voor een heldere structuur en maakt het makkelijker te volgen.

> Als je verder wilt gaan dan de basis van commits, behandelt de Intermediate Git-cursus meer geavanceerde concepten zoals amend, rebase en het beheren van commithistorie in teams.

Geavanceerde Git commit-opties

De -m-vlag is een veelgebruikte optie bij git commit-commando’s en volstaat voor dagelijks gebruik. Er zijn echter verschillende andere geavanceerde opties die meer flexibiliteit en efficiëntie bieden bij het beheren van wijzigingen. In deze sectie bekijken we die opties. 

Committen zonder staging

In veel gevallen kan handmatig bestanden stagen met git add vóór het committen onnodig aanvoelen, vooral wanneer alle gewijzigde bestanden gecommit moeten worden. Om dit te versnellen biedt Git de -a-vlag, die alle gevolgde bestanden staget en ze in één stap commit. Dit betekent dat alle wijzigingen aan eerder gevolgde bestanden worden meegenomen in de commit zonder expliciet git add uit te voeren.

Zo werkt het:

git commit -a -m “Your commit message” 

Een commit amenden

Fouten gebeuren. Soms moet je een zojuist gemaakte commit wijzigen. Met de optie --amend kun je de meest recente commit aanpassen in plaats van een nieuwe te maken. Zo kun je het commit-bericht bijwerken of extra bestanden aan dezelfde commit toevoegen.

Bijvoorbeeld, om het bericht van de laatste commit te corrigeren: 

git commit --amend -m "Update commit message"

Of, als je een bestand vergat te stagen, voeg het bestand eerst toe en amend daarna de commit:

git add missed-file.txt
git commit --amend

Hiermee vervang je de vorige commit effectief door de bijgewerkte versie. 

Let op: amenden moet je alleen doen voor commits die nog niet met anderen zijn gedeeld (bijv. niet gepusht naar een gedeelde repository), om te voorkomen dat je geschiedenis herschrijft waar anderen op vertrouwen!

Committen met wijzigingen en bestanden van een specifieke commit

Soms moet je een eerdere commit corrigeren zonder ongerelateerde wijzigingen te maken. Git biedt de optie --fixup, waarmee je een vervolgcommit maakt die specifiek is gekoppeld aan een eerdere commit. Dit is vooral handig wanneer je je commithistorie wilt opschonen voordat je je wijzigingen merge’t.

Bijvoorbeeld, om een fixup te maken voor een specifieke commit:

git commit --fixup <commit-hash>

Dit commando maakt een nieuwe commit die bedoeld is om problemen in de opgegeven commit aan te pakken. 

Later, wanneer je een interactieve rebase uitvoert, kan Git deze fixup-commits automatisch samenvoegen met de oorspronkelijke commit waarnaar ze verwijzen.

> Voor geavanceerdere workflows zoals commits samenvoegen (squashen), kun je onze gedetailleerde walkthrough volgen in de tutorial over Git Squash Commits.

Commits beheren met Git

Naarmate je project groeit en de commithistorie toeneemt, wordt het beheren van commits cruciaal om een georganiseerde en navigeerbare repository te behouden. Effectief commitbeheer helpt bij debuggen, samenwerking en het behouden van een schone, begrijpelijke geschiedenis. 

Git biedt krachtige tools waarmee je de commithistorie kunt bekijken en indien nodig wijzigingen kunt herzien of zelfs ongedaan maken. Weten hoe je commits beheert, kan veel tijd besparen bij het oplossen van problemen of het verfijnen van de geschiedenis van je project.

Commitgeschiedenis bekijken

Een cruciaal onderdeel van commitbeheer is inzicht in de geschiedenis van het project. Met het commando git log bekijk je een gedetailleerde geschiedenis van je commits. Dit geeft context zoals wanneer wijzigingen zijn gemaakt, door wie en welke berichten erbij horen.

Bijvoorbeeld, het basiscommando git log ziet er zo uit:

git log

Dit toont commit-hashes, auteursnamen, data en commit-berichten. 

Maar Git laat je ook de log-uitvoer aanpassen aan specifieke behoeften. Zo kun je het aantal weergegeven commits beperken als volgt: 

git log -n 5 # shows the last 5 commits

Gebruik de vlag -p om de wijzigingen in elke commit te inspecteren; deze toont de diff per commit. 

Zo ziet dat eruit:

git log -p

Een commit terugdraaien of ongedaan maken

Soms moet je een stap terug doen of wijzigingen ongedaan maken. Een veilige manier om een commit ongedaan te maken is door g de git revert-opdracht te gebruiken. Dit creëert een nieuwe commit die de wijzigingen van een eerdere commit ongedaan maakt zonder de commithistorie te wijzigen. 

Dit is vooral nuttig wanneer je commits al met anderen hebt gedeeld en je de geschiedenis intact wilt houden.

Om een commit te reverten, gebruik je het volgende:

git revert <commit-hash>

Dit commando past het omgekeerde toe van de wijzigingen uit de opgegeven commit, waardoor ze effectief worden teruggedraaid terwijl de geschiedenis transparant blijft.

Een commit resetten

In sommige gevallen wil je je repository volledig resetten naar een eerdere staat en één of meer commits verwijderen. Met de git reset-opdracht kan dat. Het resetten van een commit wijzigt echter de commithistorie, dus gebruik dit met beleid—zeker als de wijzigingen al zijn gepusht naar een gedeelde repository.

Git reset biedt drie modi:

1. Soft reset: Zet de commit-pointer terug naar een opgegeven commit maar behoudt de wijzigingen in de working directory en de staging area. Handig als je een commit opnieuw wilt doen maar je wijzigingen wilt behouden. 

git reset --soft <commit-hash>

2. Mixed reset: Zet de commit-pointer terug naar een opgegeven commit en behoudt de wijzigingen in de working directory, maar leegt de staging area. Dit is de standaard resetmodus van Git.

git reset --mixed <commit-hash>

3. Hard reset: Zet de commit-pointer terug naar een opgegeven commit en gooit alle wijzigingen weg in zowel de working directory als de staging area. Dit zet je repository feitelijk terug naar de staat van de gekozen commit en verwijdert alle wijzigingen die daarna zijn gemaakt. 

git reset --hard <commit-hash>

Het commando git reset is krachtig, maar het is essentieel om de gevolgen te begrijpen (vooral in een samenwerkingsomgeving).  

Best practices voor committen in Git

Effectief versiebeheer vraagt om meer dan alleen Git-commando’s kennen—het betekent ook dat je bepaalde best practices volgt om een schone, begrijpelijke en efficiënte projectgeschiedenis te behouden. Deze praktijken helpen niet alleen bij het beheren van je eigen werk, maar maken het ook makkelijker voor anderen om bij te dragen en wijzigingen te reviewen.

Commit vaak, maar houd het klein

Een goede vuistregel is: commit vroeg en vaak, maar houd elke commit klein en gefocust. Zo staat elke commit voor een duidelijk en logisch stukje werk. 

Vaak committen helpt om grote wijzigingen op te delen in behapbare stukken, wat reviewen, testen en het volgen van de evolutie van je project eenvoudiger maakt. Door kleinere, geïsoleerde aanpassingen te committen, verklein je ook de kans op complexe fouten. Gaat er toch iets mis, dan is het eenvoudiger het probleem te isoleren en op te lossen als commits fijnmazig zijn.

Commit alleen gerelateerde wijzigingen

Elke commit moet zich richten op één taak of issue. Ongerelateerde wijzigingen in één commit vermengen, maakt het lastiger om te reviewen en de intentie achter de aanpassingen te begrijpen. Het bemoeilijkt ook het terugdraaien of cherry-picken van specifieke wijzigingen indien nodig.

Als je bijvoorbeeld aan een feature werkt maar elders in de code een kleine bug ziet, pak die dan beter op in een aparte commit. Zo blijft duidelijk wat er is gedaan en waarom—en zorg je dat elke commit betekenisvol en geïsoleerd is.

Werk samen aan de commithistorie

Als je in een team werkt, is het essentieel om met je collega’s af te stemmen hoe commits worden afgehandeld en gepresenteerd. Dit omvat overeenstemming over een consistente opmaak van commit-berichten en erop toezien dat iedereen best practices volgt. Git hooks, zoals pre-commit hooks, kunnen helpen regels af te dwingen, zoals het formaat van commit-berichten of het draaien van tests voordat een commit is toegestaan.

Samenwerking wordt ook versterkt door tools die helpen commits te beheren en te reviewen, zoals code review-platforms zoals GitHub of GitLab. Een duidelijke, goed gedocumenteerde commithistorie maakt het makkelijker voor teamleden om wijzigingen te begrijpen, verbeteringen te bespreken en het project efficiënt vooruit te helpen.

> Wil je achtergebleven bestanden opruimen vóór je commit? Leer git clean gebruiken in deze tutorial over het verwijderen van niet-bijgehouden bestanden.

Veelvoorkomende Git commit-problemen oplossen

Git-commits kunnen soms fouten of uitdagingen opleveren die je workflow vertragen. Begrijpen hoe je deze veelvoorkomende problemen oplost, is cruciaal om soepel versiebeheer te behouden en grotere problemen later te voorkomen.

Fouten in commit-berichten

Een veelgemaakte fout bij committen is vergeten een commit-bericht toe te voegen of per ongeluk een vaag of leeg bericht gebruiken. Duidelijke en informatieve commit-berichten zijn essentieel om wijzigingen bij te houden en zodat anderen de geschiedenis van een project begrijpen. Git voorkomt doorgaans dat je zonder bericht commit, maar de kwaliteit van het bericht kun je alsnog over het hoofd zien.

Oplossing: Controleer je commit-bericht altijd voordat je op enter drukt. Als je per ongeluk een commit met een leeg of onduidelijk bericht hebt ingediend, kun je dit corrigeren met git commit --amend om het meest recente commit-bericht te wijzigen. 

Conflicten na een commit

Conflicten zijn onvermijdelijk wanneer meerdere mensen aan hetzelfde project werken. Ze ontstaan vaak na een commit wanneer je branches merge’t of rebase’t. Een conflict ontstaat wanneer Git verschillen tussen twee commits niet automatisch kan oplossen, waardoor jij handmatig moet kiezen welke wijzigingen je behoudt.

Conflicten treden het vaakst op wanneer twee of meer bijdragers hetzelfde codegedeelte wijzigen of wanneer er grote refactors in een project worden gedaan. Hoewel ze intimiderend kunnen lijken, biedt Git de tools om deze conflicten op te lossen zonder data te verliezen.

Oplossing: Wanneer een conflict optreedt, markeert Git de conflicterende secties in de bestanden en moet je deze handmatig oplossen door het bestand te bewerken naar de gewenste staat. Stage daarna het bestand met git add en rond de merge of rebase af door de opgeloste wijzigingen te committen. Tools zoals de merge conflict-editor van Git of externe mergetools kunnen je helpen conflicten efficiënter op te lossen.

Conclusie

Het commando git commit is een fundament van versiebeheer in Git waarmee ontwikkelaars momentopnames van hun werk kunnen maken die in de loop van de tijd kunnen worden gevolgd, gereviewd en opnieuw bezocht. Commits fungeren als mijlpalen in de geschiedenis van een project en maken duidelijk welke wijzigingen zijn aangebracht, waarom ze nodig waren en wanneer ze zijn geïmplementeerd.

In deze tutorial hebben we de basis-syntax en het proces van committen behandeld, van bestanden stagen met git add tot het afronden van de commit met git commit. We hebben het belang besproken van duidelijke en beknopte commit-berichten en best practices zoals beschrijvend schrijven, de tegenwoordige tijd gebruiken en bondigheid. 

Daarnaast hebben we geavanceerde opties verkend, zoals committen zonder te stagen en commits amenden, wat flexibiliteit biedt bij het beheren van je wijzigingen. We hebben ook gekeken naar het beheren van commits met commando’s zoals git log, reverteren en resetten.

Klaar om GitHub verder te verkennen? Onze GitHub Concepts-cursus gaat in op forks, branches, issues en best practices voor samenwerking. Bereid je je voor op een workflow in de praktijk of een interview? De Complete Git Cheat Sheet is een handig naslagwerk!