Git-basis: commit, branch, merge

Git-basis behoort tot de belangrijkste vaardigheden in moderne softwareontwikkeling, want Git is een gedistribueerd versiebeheersysteem dat elke wijziging aan je code vastlegt. Of je nu alleen of in een team werkt, Git geeft je de kracht om fouten ongedaan te maken, te zien wie wat wanneer heeft veranderd, en parallel aan dezelfde bestanden te werken. In dit artikel leggen we de begrippen repository, staging area, commit en branch helder uit en tonen we elke stap met echte commando's.

Kernbegrippen: repository, staging area, commit

Bij het leren van de Git-basis moet je eerst de woordenschat vastleggen. Drie begrippen worden vaak verward:

• Repository: de database die de volledige geschiedenis van je project bewaart, opgeslagen in de verborgen map .git.
• Werkdirectory (working directory): de echte bestanden die je op dit moment bewerkt.
• Staging area (index): een tussenlaag waarin je precies kiest welke wijzigingen in de volgende commit komen.
• Commit: een permanent opgeslagen momentopname van de gestagede wijzigingen, voorzien van een bericht en een unieke identificatie (hash).

De flow is: je bewerkt een bestand → je staget het met git add → je schrijft het naar de repository met git commit.

Een nieuwe repository initialiseren en de eerste commit

Aan het begin van een nieuw project initialiseer je Git in de map. Je eerste taak is je identiteit instellen en de repository aanmaken:

git config --global user.name "Jouw Naam"
git config --global user.email "jij@voorbeeld.com"

mkdir mijnproject
cd mijnproject
git init

Het commando git init maakt een lege .git-repository in de map. Laten we nu een bestand toevoegen en de status controleren:

git status
git add index.html
git add .
git commit -m "Eerste commit: projectskelet"

git status toont welke bestanden zijn gewijzigd en welke gestaged zijn, en het is het commando dat je het vaakst zult gebruiken. git add . staget alle wijzigingen; git commit -m rondt de registratie af met een bericht van één regel. Schrijf betekenisvolle, korte berichten in de gebiedende wijs (bijv. "Voeg validatie van loginformulier toe").

De geschiedenis lezen: git log en git status

Om de commits te zien die je hebt gemaakt, gebruik je git log:

git log
git log --oneline --graph --decorate

--oneline verkort elke commit tot één regel, terwijl --graph de branch-structuur visueel tekent. De korte tekenreeks aan het begin van elke regel is de unieke identificatie (hash) van die commit, en daarmee kun je naar elk punt terugkeren. git status is altijd het antwoord op de vraag "waar ben ik nu?".

Branch en merge: de basis van parallel werken

Een branch is een verplaatsbare verwijzing waarmee je je kunt afsplitsen van de hoofdcode en onafhankelijk kunt werken. Bij het uitproberen van een nieuwe functie werk je op een aparte branch zonder de hoofdbranch (meestal main) te breken:

git branch feature-login
git switch feature-login

# Hetzelfde in oudere Git-versies:
git checkout -b feature-login

Hier is git switch het moderne, goed leesbare commando; git checkout -b maakt de branch aan én schakelt er in één stap naartoe. Nadat je een paar commits op de branch hebt gemaakt, breng je de wijzigingen na afronding terug naar de hoofdbranch met een merge (samenvoeging):

git switch main
git merge feature-login

# Ruim de samengevoegde branch op:
git branch -d feature-login

Als twee branches dezelfde regels van hetzelfde bestand op verschillende manieren wijzigen, meldt Git een conflict. In dat geval open je het bestand, herstel je handmatig de delen tussen de markeringen <<<<<<< en >>>>>>>, en voltooi je de samenvoeging met git add + git commit.

Werken met remote repositories: clone, pull, push

Omdat Git gedistribueerd is, wordt code meestal gedeeld op een remote repository zoals GitHub of GitLab. Om een bestaand project te downloaden:

git clone https://github.com/gebruiker/project.git

Om je eigen lokale repository aan een bestaande remote te koppelen en te versturen:

git remote add origin https://github.com/gebruiker/project.git
git push -u origin main

De dagelijkse cyclus is eenvoudig: gebruik git pull om de wijzigingen van je teamgenoten op te halen, en git push om je eigen commits te uploaden:

git pull
git push

De -u in het eerste git push -u origin main koppelt de lokale branch aan de remote branch; daarna is een eenvoudige git push voldoende.

Ongewenste bestanden uitsluiten met .gitignore

Mappen met afhankelijkheden, build-uitvoer en geheime sleutels mogen nooit in de repository terechtkomen. Je maakt een .gitignore-bestand in de hoofdmap van het project om aan te geven welke bestanden genegeerd moeten worden:

node_modules/
vendor/
.env
*.log
/dist
.DS_Store

Een belangrijke regel: .gitignore werkt alleen voor bestanden die nog niet gevolgd worden. Als je een bestand per ongeluk al hebt gecommit, moet je het eerst uit de tracking halen met git rm --cached bestand.

Veelgestelde vragen

Wat is het verschil tussen git add en git commit?

git add verplaatst wijzigingen naar de staging area, alsof je zegt "ik wil deze opslaan"; git commit schrijft die gestagede wijzigingen vervolgens definitief naar de repository met een bericht. Zonder add legt een commit niets vast.

Is er een verschil tussen git checkout en git switch?

Beide kunnen van branch wisselen. git switch is een nieuwer, duidelijker commando dat alleen voor branch-bewerkingen is ontworpen; git checkout wisselt van branch én herstelt bestanden, en is daardoor complexer. Beginners wordt aangeraden git switch te gebruiken.

Hoe corrigeer ik mijn laatste commit-bericht?

Als je nog niet hebt gepusht, kun je de laatste commit herschrijven met git commit --amend -m "Nieuw bericht". Na een push beïnvloedt het wijzigen van de geschiedenis je teamgenoten, dus wees voorzichtig.

Wil je een solide Git- en deployment-workflow voor je project opzetten? Heb je hulp nodig bij versiebeheer, codekwaliteit en automatisering, neem dan contact met me op — laten we samen een workflow ontwerpen die bij je project past.