Conflicten oplossen

Wat is een Merge Conflict?

Wanneer je samenwerkt aan een project in Git, werk je vaak tegelijkertijd met anderen aan dezelfde bestanden. Git helpt om wijzigingen van verschillende mensen samen te voegen (merge), maar soms lukt dat niet automatisch. Dit gebeurt wanneer twee of meer mensen dezelfde regel in een bestand wijzigen. Dit noemen we een merge conflict.

Een merge conflict betekent dat Git niet weet welke versie de juiste is, en jij moet beslissen welke code behouden blijft.

Metafoor: Een gezamenlijke tekst schrijven

Stel je voor dat jij en een vriend een verslag schrijven in een schrift.

Jij schrijft op een pagina:
```
Ik hou van pizza.
```
Ondertussen, zonder dat jij het weet, heeft je vriend op dezelfde regel geschreven:
```
Ik hou van sushi.
```
Wanneer jij jouw versie inlevert, zegt de leraar: "Wacht, er zijn twee versies! Welke is correct?"

Dit is precies wat Git doet bij een merge conflict: het vraagt jou om te kiezen welke versie je wilt behouden.

Merge Conflicts in Git: Wanneer gebeuren ze?

Een merge conflict ontstaat meestal wanneer:

Je wijzigingen lokaal hebt gemaakt, maar iemand anders heeft intussen dezelfde regel gewijzigd in de remote repository.
Je probeert jouw code naar de server te pushen, maar Git weigert omdat er nieuwe wijzigingen zijn die je eerst moet verwerken.

Praktische Simulatie: Een Merge Conflict Oplossen

In deze oefening ga je een merge conflict zelf simuleren en oplossen.

Stap 1: Voorbereiding

Open een terminal en maak een nieuwe testmap:

mkdir git-merge-conflict-demo && cd git-merge-conflict-demo

Initialiseer een nieuwe Git-repository:
```
git init
```
Maak een bestand bestand.txt en voeg de volgende regel toe:
```
Hallo, dit is mijn eerste regel.
```

Voeg het bestand toe aan Git en commit:

git add bestand.txt
git commit -m "Eerste commit"

Koppel de repository aan een GitHub-repository (vervang <URL> door de echte URL van jouw repo):
```
git remote add origin <URL>
git push -u origin main
```

Stap 2: Simuleer een wijziging op GitHub

Open jouw repository op GitHub.
Bewerk bestand.txt direct via de GitHub-interface en wijzig de regel naar:
```
Hallo, dit is een wijziging op GitHub.
```
Sla de wijziging op en commit direct naar de main branch.

Stap 3: Simuleer een lokale wijziging

Ga terug naar jouw terminal en bewerk lokaal bestand.txt.
Wijzig de regel naar:
```
Hallo, dit is een lokale wijziging.
```

Commit jouw wijziging lokaal:

git commit -am "Lokale wijziging gemaakt"

Probeer nu je code naar GitHub te pushen:
```
git push origin main
```

🚨 Dit zal mislukken, omdat Git detecteert dat er wijzigingen op GitHub zijn die niet lokaal zijn binnengehaald!

Stap 4: Los het merge conflict op

Trek eerst de nieuwste wijzigingen op via een rebase:
```
git pull --rebase origin main
```

Git zal melden dat er een merge conflict is:

CONFLICT (content): Merge conflict in bestand.txt

Open VS Code en bekijk het bestand bestand.txt. Daar zie je iets zoals:

<<<<<<< HEAD
Hallo, dit is een lokale wijziging.
=======
Hallo, dit is een wijziging op GitHub.
>>>>>>> main

Kies de gewenste versie:
- Behoud jouw versie
- Behoud de GitHub-versie
- Combineer beide versies
Sla het bestand op en markeer het als opgelost:
```
git add bestand.txt
```
Rond de rebase af:
```
git rebase --continue
```
Push nu je code naar GitHub:
```
git push origin main
```

Enkele leerijke video's

Never fear merge conflicts again - git merge/pull tutorial

git rebase - Why, When & How to fix conflicts

PreviousRemote Repositories en Samenwerken NextComputer Hardware

Last updated 1 month ago