Git gebruikt branches om ontwikkelingsstromen te isoleren, om te voorkomen dat de stable release branch vervuild raakt. Werk in een branche in de hoofdstroom brengen betekent vestigingen samenvoegen. Hier is hoe je het doet.
Wat is een samenvoeging in Git?
Voorbereidingen voor het samenvoegen van een filiaal in Git
Een samenvoeging uitvoeren
Een snelle samenvoeging uitvoeren in Git
Samenvoegconflicten in Git oplossen
Alles komt uiteindelijk samen
Wat is een samenvoeging in Git?
Git is ontworpen om vertakking eenvoudig en snel te maken. In tegenstelling tot andere versiebeheersystemen is branching op Git een triviale zaak. Vooral bij projecten met meerdere ontwikkelaars is vertakking een van de belangrijkste organisatorische tools van Git.
Branches sandboxen nieuwe ontwikkelingsinspanningen zodat code kan worden gewijzigd of toegevoegd zonder de code in andere branches te beïnvloeden, met name de main- of master-branch. Deze bevat meestal de stabiele versie van uw codebase.
Het is volkomen logisch om deze wijzigingen te isoleren van uw stabiele codeversie. Maar vroeg of laat zal de nieuwe code getest, beoordeeld en gestempeld worden om in de master branch te worden gerold. Op dat moment moet je je branch mergen in de master branch.
In feite kunnen branches sub-branches hebben, dus het zou kunnen dat je jouw branch aan het mergen bent in een andere branch in plaats van de master branch. Onthoud gewoon dat samenvoegingen altijd één tak nemen en deze samenvoegen tot een doel tak, wat die tak ook mag zijn. Als je je master branch wilt mergen in een andere branch, dan kan dat ook.
Zoals de meeste acties in Git, voer je samenvoegingen uit in je lokale repository en push je ze naar je externe repository.
Voorbereidingen voor het samenvoegen van een filiaal in Git
We hebben een klein ontwikkelingsproject met een lokale Git-repository en een externe Git-repository. We creëerden een branch genaamd “bugfix14” van de “master” branch en werkten aan een oplossing voor een bug.
Dat werk is voltooid en we hebben onze code getest. Het werkt allemaal zoals verwacht. We willen die wijzigingen in de master branch doorvoeren, zodat onze oplossing deel uitmaakt van de volgende release van de software.
Er is een kleine voorbereiding nodig voordat we de samenvoeging uitvoeren. We moeten er zeker van zijn dat de doelbranch – in dit geval de “master” -branch – en de branch die we erin gaan mergen, beide up-to-date zijn.
Hiervoor gebruiken we de git status opdracht.
git status
- Op tak bugfix14: Dit is onze huidige vestiging.
- Je branch is up-to-date met ‘origin/bugfix’: De branch in onze lokale repository heeft dezelfde commit geschiedenis als de branch in de remote repository. Dat betekent dat ze identiek zijn.
- niets te plegen Er zijn geen wijzigingen in het verzamelgebied die niet zijn vastgelegd.
- werkende boom schoon: Er zijn geen ongestage wijzigingen in de werkdirectory.
Al deze geven aan dat de branche up-to-date is en dat we verder kunnen gaan. Als een van deze aangaf dat er wijzigingen waren, moesten we ze in scène zetten, vastleggen en naar de afstandsbediening pushen. Als iemand anders aan deze bestanden heeft gewerkt, moeten we mogelijk hun wijzigingen uit de externe repository halen.
Het bekijken van de branche waarin we gaan samenvoegen vereenvoudigt het samenvoegingsproces. Het stelt ons ook in staat om te controleren of het up-to-date is. Laten we eens kijken naar de master branch.
git checkout master
git status
We krijgen dezelfde bevestigingen dat de “master” branch up-to-date is.
Een samenvoeging uitvoeren
Voordat we samenvoegen, zien onze commits er zo uit.
De tak “bugfix14” was vertakt van de tak “master”. Er is een commit geweest naar de “master” branch nadat de “bugfix14” branch was aangemaakt. Er zijn een aantal commits geweest naar de “bugfix14” branch.
We hebben ervoor gezorgd dat onze twee branches up-to-date zijn, en we hebben de “master” branch uitgecheckt. We kunnen het commando geven om de branch “bugfix14” samen te voegen met de branch “master”.
git merge bugfix14
De samenvoeging vindt plaats. De branch “bugfix14” bestaat nog steeds, maar nu zijn de wijzigingen die in die branch zijn gemaakt samengevoegd in de branch “master”.
In dit geval voert het samenvoegcommando a drievoudige samenvoeging. Er zijn slechts twee branches, maar er zijn drie commits bij betrokken. Ze zijn het hoofd van elke branch en een derde commit die de samenvoegactie zelf vertegenwoordigt.
Om onze externe repository bij te werken, kunnen we de git push opdracht.
git push
Sommige mensen geven er de voorkeur aan zijtakken te verwijderen nadat ze ze hebben samengevoegd. Anderen zorgen ervoor dat ze worden bewaard als een verslag van de ware ontwikkelingsgeschiedenis van het project.
Als u de tak wilt verwijderen, kunt u dit doen met behulp van de git branch commando met de -d (verwijderen) optie.
git branch -d bugfix14
Gebruik deze opdracht om de vertakking in de externe repository te verwijderen:
git push origin --delete bugfix14
Je zult een lineaire commit geschiedenis hebben, maar het zal niet de ware geschiedenis zijn.
Een snelle samenvoeging uitvoeren in Git
Als je nog geen commits hebt gedaan naar de “master” branch, zal je historie er zo uitzien. Het zal er ook zo uitzien als je je development branch hebt gerebased zodat deze aan het einde van de “master” branch is gekoppeld.
Omdat er geen commits zijn in de “master” branch, hoeft Git om de “bugfix15” branch samen te voegen alleen de “master” head pointer te wijzen naar de laatste commit van de “bugfix15” branch.
We kunnen het gebruikelijke gebruiken git merge opdracht:
git merge bugfix15
Dat geeft ons dit resultaat.
Wat hetzelfde is als dit:
Wat precies hetzelfde is als dit:
Git zal een fast-forward merge uitvoeren wanneer het maar kan. Als commits naar de “master” branch betekenen dat een fast-forward merge niet mogelijk is, zal Git een drievoudige samenvoeging.
Dat kan niet kracht een snelle voorwaartse samenvoeging – het is tenslotte misschien niet mogelijk – maar u kunt aangeven dat het een snelle voorwaartse samenvoeging wordt of niets. Er is een optie die Git instrueert om een fast-forward merge te gebruiken als het kan, maar geen three-way merge te doen als dat niet kan. De optie is --ff-only (alleen snel vooruit samenvoegen).
Dit voegt de tak “bugfix15” samen met de tak “master”, maar alleen als een snelle samenvoeging mogelijk is.
git merge --ff-only bugfix15
Git zal klagen en afsluiten als het niet mogelijk is.
git merge --ff-only bugfix16
In dit geval zijn er commits geweest naar de “master” branch, dus een fast-forward merge is niet mogelijk.
Samenvoegconflicten in Git oplossen
Als dezelfde delen van hetzelfde bestand in beide takken zijn gewijzigd, kunnen de takken niet worden samengevoegd. Menselijke interactie is vereist om de conflicterende bewerkingen op te lossen.
Hier hebben we wijzigingen aangebracht in een bestand genaamd “rot.c” in een branch genaamd “bugfix17” die we willen samenvoegen met de “master” branch. Maar “rot.c” is ook veranderd in de “master” branch.
git merge bugfix17
Wanneer we het proberen samen te voegen, krijgen we een waarschuwing dat er conflicten zijn. Git somt de conflicterende bestanden op en vertelt ons dat het samenvoegen is mislukt. We zouden ons volledig kunnen terugtrekken met behulp van de --abort optie:
git merge --abort
Maar het oplossen van samenvoegingen is niet zo eng als het klinkt. Git heeft wat werk verzet om ons te helpen. Als we een van de conflicterende bestanden bewerken – in ons geval hebben we er maar één – zullen de conflicterende codesecties voor ons gemarkeerd zijn.
Elk conflict wordt begrensd door zeven minder-dan-tekens “<<<<<<<” en zeven groter-dan-tekens “>>>>>>>“, met zeven gelijktekens “=======” tussen hen.
- De code boven de gelijktekens is van de branch die je aan het mergen bent naar binnen.
- De code onder het gelijkteken is de code van de branch die je probeert te gebruiken samenvoegen.
U kunt eenvoudig zoeken naar een van de sets van zeven tekens en van conflict naar conflict gaan door uw bestand. Voor elk conflict moet u kiezen welke set bewerkingen u wilt behouden. Je moet de code die je afwijst verwijderen, en de regels van zeven tekens die Git heeft toegevoegd.
We gaan de code van de tak “bugfix17” behouden. Na het bewerken ziet ons bestand er zo uit.
We kunnen nu verder met de samenvoeging. Maar let op, we gebruiken de commit opdracht om dit te doen, niet de merge opdracht.
We committen de wijziging door het bestand te stagen en zoals gewoonlijk te committen. We controleren de status voordat we de definitieve commit maken.
git add rot.c
git status
git commit -m "Merged bugfix17"
De samenvoeging is voltooid. We kunnen dit nu naar onze externe repository pushen.
Alles komt uiteindelijk samen
Alle branches moeten uiteindelijk worden samengevoegd, zodat de wijzigingen daarin niet verweesd en vergeten worden.
Filialen samenvoegen is eenvoudig, maar het omgaan met conflicten kan ingewikkeld worden in drukke, grotere teams. Het oplossen van conflicten kan input van elke ontwikkelaar vereisen, alleen maar om uit te leggen wat hun code doet en waarom ze hun wijzigingen hebben aangebracht. U moet dat begrijpen voordat u een weloverwogen beslissing kunt nemen over welke bewerkingen u wilt behouden.
Git kan daar helaas niet bij helpen.
