Git merge-tutorial: een complete gids met voorbeelden

Leer met deze stapsgewijze tutorial hoe je branches efficiënt merge’t in Git. Verken verschillende merges, los conflicten op en pas best practices toe om je Git-geschiedenis schoon te houden.

Bijgewerkt 2 okt 2026 · 15 min lezen

Verken met AI

ChatGPT Claude Perplexity

Als je ooit aan een project met meerdere developers hebt gewerkt (of zelfs meerdere features zelf hebt beheerd), weet je dat branching essentieel is om alles georganiseerd te houden. Maar op een gegeven moment moeten al die branches weer samenkomen—en daar komt git merge om de hoek kijken.

In deze tutorial loop ik door de verschillende typen Git-merges, hoe ze werken en hoe je mergeconflicten oplost als het niet volgens plan gaat. Tot slot deel ik enkele best practices om git merge effectief te gebruiken en veelvoorkomende valkuilen te vermijden.

Wat is git merge?

In een team werken developers vaak aan verschillende features, bugfixes en verbeteringen in aparte branches. Zodra hun werk klaar is, gebruiken ze git merge om die wijzigingen te integreren.

Mergen combineert wijzigingen van de ene branch in een andere, terwijl de volledige versiegeschiedenis behouden blijft. Het verenigt de commitgeschiedenis van beide branches.

Laten we de workflow begrijpen aan de hand van een voorbeeld.

Een gemeenschappelijke basiscommit splitst zich in twee branches, wat leidt tot aparte tips voor main en feature voordat er wordt gemerged. Afbeelding door de auteur.

In de bovenstaande afbeelding hebben de feature- en main-branches nieuwe commits gemaakt sinds de featurebranch is aangemaakt.

Een featurebranch en de mainbranch wijken af vanaf een gemeenschappelijke basis en worden later samengevoegd tot één mergecommit. Afbeelding door de auteur.

Git merge neemt alle nieuwe commits van beide branches vanaf hun gemeenschappelijke basis en combineert ze in één mergecommit. Vervolgens werkt het de head-pointer bij zodat die naar deze nieuwe mergecommit wijst.

Basisgebruik van de git merge-opdracht

Mergen is niet alleen git merge draaien en klaar—er zijn een paar belangrijke stappen om eerst alles op orde te krijgen. In deze sectie lopen we het hele proces door, van het voorbereiden van je branches tot het afronden van een succesvolle merge.

Stap 1: Voorbereiden op een merge

Alleen gecommitte wijzigingen in beide branches kunnen worden gemerged. Gebruik dus de opdracht git status om te controleren op niet-gecommitte wijzigingen en commit ze met de opdracht git commit voordat je merge uitvoert.

Stap 2: Checkout de targetbranch

Voordat je git merge uitvoert, moet je overschakelen naar de targetbranch, meestal de mainbranch. Schakel over naar de mainbranch met git checkout main of git switch main.

Stap 3: Een branch mergen

Zorg dat de mainbranch up-to-date is met de remote repository. Voer hiervoor git pull origin main uit.

Nu ben je eindelijk klaar om de featurebranch in de mainbranch te mergen! Je kunt een opdracht als de volgende gebruiken:

git merge feature-branch

Stap 4: Mergeconflicten oplossen (indien aanwezig)

Git probeert automatisch conflicten op te lossen die tijdens merges kunnen optreden. Maar handmatig ingrijpen kan nodig zijn als het het conflict niet zelf kan oplossen.

Als bijvoorbeeld dezelfde regels in hetzelfde bestand in verschillende branches zijn gewijzigd, kunnen er mergeconflicten ontstaan.

Wanneer Git een conflict detecteert, pauzeert het de merge en vraagt het je om dit op te lossen. In dat geval:

Voer git status uit om te zien welke bestanden conflicten hebben.
Open die bestanden.
Bekijk de conflicterende regels code en werk ze bij zodat ze consistent zijn in beide branches.

Stap 5: De merge committen

Gebruik na het oplossen van conflicten de opdracht git add . om de aangepaste bestanden te stagen. Rond vervolgens de merge af door te committen met een bericht:

git merge -m “resolved conflicts”

In de latere secties zien we uitgebreider hoe je mergeconflicten oplost.

Voor beginners vind je hier een complete Git-cheatsheet met alle essentiële opdrachten voor het maken, bijwerken, verwijderen en beheren van branches.

Als je al wat Git-ervaring hebt en een opfrisser nodig hebt van de belangrijkste opdrachten, bekijk dan deze tutorial met de meest gebruikte Git-opdrachten met voorbeelden.

Typen merges in Git

Als je de typen Git-merge begrijpt, kun je de juiste strategie kiezen voor jouw situatie. Dit zijn de drie gangbare manieren van mergen.

Fast-forward merge

Wanneer de basisbranch geen nieuwe commits heeft sinds de featurebranch is aangemaakt, gebruikt Git een fast-forward-aanpak.

Als je nieuwe featurebranch wordt bijgewerkt terwijl de mainbranch ongewijzigd blijft, verplaatst de mergecommit de head-pointer van main naar de featurebranch.

Er wordt geen extra mergecommit aangemaakt, wat de commitgeschiedenis schoon en lineair houdt.

Three-way merge

Als zowel de basis- als de featurebranch nieuwe commits hebben, zoekt Git hun gemeenschappelijke voorouder en maakt een nieuwe mergecommit. Deze commit combineert de geschiedenissen van beide branches en behoudt de individuele geschiedenis van zowel de featurebranch als de mainbranch.

In het onderstaande voorbeeld zijn “E” en “G” nieuwe commits aan de mainbranch nadat de featurebranch is aangemaakt.

      C---D---F (feature-branch)
     /         
A---B---E---G (main)

Er wordt een nieuwe mergecommit “M” aangemaakt, die de geschiedenis van zowel main als feature behoudt.

       C---D---F
      /         \
 A---B---E---G---M (main)

Squash merge

Squash merge combineert alle wijzigingen van een featurebranch in één commit en merge’t die in de targetbranch. De individuele commitgeschiedenis van de featurebranch blijft niet behouden.

git merge --squash feature_branch_name

Een squash-merge is vooral handig om rommel van meerdere kleine commits te vermijden, terwijl de uiteindelijke staat van de feature in de targetbranch behouden blijft.

Meerdere branches mergen

Bij grote projecten moet je mogelijk meerdere branches mergen—ofwel één voor één of allemaal tegelijk. De aanpak hangt af van je workflow en de complexiteit van de wijzigingen. In deze sectie verken ik beide methoden en wanneer je ze effectief inzet.

Meer dan één branch achtereenvolgens mergen

Om branches één voor één te mergen, gebruik je het merge-commando achtereenvolgens voor elke featurebranch.

Stap 1: Schakel over naar de targetbranch waarin je de wijzigingen wilt mergen.

git checkout target_branch_name

Stap 2: Merge de eerste featurebranch, zoals hieronder.

git merge feature_branch_1

Stap 3: Merge de tweede featurebranch zoals getoond.

git merge feature_branch_2

Herhaal dit proces totdat alle andere branches zijn gemerged.

Meer dan één branch parallel mergen

Volg deze stappen om meerdere featurebranches in één keer te mergen.

Stap 1: Schakel over naar de targetbranch waarin je de wijzigingen wilt mergen.

git checkout target_branch_name

Stap 2: Voer de volgende opdracht uit met meerdere featurebranches

git merge feature_branch_1 feature_branch_2 feature_branch_3

Wanneer Git meerdere branches parallel merge’t, kunnen er conflicten optreden. Als dat gebeurt, vraagt Git je om ze handmatig op te lossen.

Omgaan met conflicten bij meerdere merges

Meerdere branches mergen is niet altijd eenvoudig—zeker niet als de ene branch afhankelijk is van de andere.

Als je bijvoorbeeld feature_x in main merge’t vóór feature_y, kan dat conflicten veroorzaken. Evenzo kunnen parallelle merges leiden tot conflicten als verschillende branches dezelfde bestanden wijzigen, en die moeten zorgvuldig worden opgelost.

Volg deze stappen om mergeconflicten op te lossen:

Stap 1: Voer git status uit om te zien welke bestanden conflicten veroorzaken.
Stap 2: Open de conflicterende bestanden en corrigeer ze.
Stap 3: Voeg de wijzigingen toe aan de stage en commit ze.

De geschiedenis van mergecommits begrijpen

Voor complexe conflicten heb je mogelijk meer informatie nodig dan git status biedt. In zulke gevallen kun je opdrachten als git log of git show gebruiken om diep in de geschiedenis te duiken.

git log: toont de volledige commitgeschiedenis, inclusief mergecommits. Dit helpt een specifieke merge te identificeren waar het probleem optreedt.
git show: Als je met de bovenstaande opdracht een verdachte mergecommit vindt, gebruik dan git show om die te inspecteren. Deze opdracht geeft een gedetailleerd overzicht van de commit en laat zien wat er tijdens de merge is gewijzigd. Hij toont ook een unieke identifier voor de parentbranch vóórdat een specifieke merge plaatsvond.
git diff: Je kunt de unieke identifiers van de parent- en gemergde branches uit de vorige opdrachten nemen en git diff gebruiken om de verschillen tussen deze twee toestanden te vergelijken.

Best practices voor Git-merges

Mergen kan soms rommelig zijn, vooral wanneer meerdere developers aan dezelfde codebase werken.

We hebben besproken hoe je conflicten oplost wanneer ze zich voordoen, maar de beste aanpak is om ze te voorkomen voordat ze gebeuren. In deze sectie behandelen we praktische tips om je merges soepel te laten verlopen en je Git-geschiedenis netjes te houden.

Houd branches klein en gefocust

Grote branches vergroten de kans op overlappende edits, wat tot meer conflicten leidt. Minimaliseer dit door per branch aan één feature te werken en branches klein en gefocust te houden.

Frequent pullen en mergen

Haal de nieuwste wijzigingen op uit de remote repository om je basisbranch up-to-date te houden voordat je merge’t. Pull regelmatig updates van de mainbranch in je featurebranch om ze synchroon te houden. Dit voorkomt later grote en complexe conflicten.

Gebruik de ingebouwde mergetools van Git

In plaats van bestanden handmatig te bewerken, kun je de ingebouwde tools van Git gebruiken om conflicten in een visuele UI op te lossen. Wanneer je git mergetool uitvoert, gaan er drie keuzes open:

LOCAL - Versie van de mainbranch. Deze keuze behoudt de inhoud van het conflicterende bestand uit de mainbranch en negeert de wijzigingen uit de featurebranch.
REMOTE - De versie van de featurebranch. Deze optie past de inhoud van de featurebranch toe op het conflicterende bestand.
BASE - Dit combineert de wijzigingen van de conflicterende bestanden uit beide branches en merge’t ze.

Merge in de juiste volgorde

Bij het mergen van meerdere branches is de volgorde belangrijk—vooral als de ene feature afhankelijk is van de andere. Als feature_x afhankelijk is van feature_y, kan het mergen van feature_x eerst conflicten introduceren. Om dit te voorkomen, merge je branches altijd in de volgorde van hun afhankelijkheden, zodat het proces soepel verloopt en conflicten worden geminimaliseerd.

Squash merging

Zoals eerder genoemd, voegt squash merging alle commits uit een featurebranch samen tot één commit, waardoor de commitgeschiedenis schoon blijft en potentiële mergeconflicten verminderen.

Een alternatieve aanpak is rebasen, waarbij de wijzigingen van de featurebranch direct bovenop de basisbranch worden toegepast. Dit creëert een lineaire geschiedenis en voorkomt onnodige mergecommits. Beide methoden herschrijven echter de geschiedenis en behouden de individuele commits van de featurebranch niet.

Conclusie

In deze Git-merge-tutorial hebben we alles behandeld van de basis van mergen tot best practices om conflicten te vermijden. Begrijpen hoe je git merge effectief gebruikt, helpt teams soepel samen te werken, met gestroomlijnde workflows en een schone codegeschiedenis.

Wil je je Git-vaardigheden verdiepen, bekijk dan deze intermediate Git-cursus om meer geavanceerde workflows en technieken onder de knie te krijgen!