Als je Git gebruikt voor versiebeheer van de broncode, moet je mogelijk verschillende ontwikkelingsbranches voor een project samenvoegen tot één enkele branch. Dit artikel zal je begeleiden bij het samenvoegen van twee ontwikkelingsbranches met het Git samenvoeg commando.
We laten je zien hoe je een Git-project kunt maken, verschillende branches kunt maken en één branch in een andere kunt samenvoegen. Daarnaast leer je wat een snellewoord-samenvoeging is en wat een 3-weg-samenvoeging is, en hoe je een branch samenvoegt in een externe repository.
Wat is Git samenvoegen?
Git is een populair DevOps-gereedschap dat ontwikkelaars kunnen gebruiken om wijzigingen bij te houden en te beheren in code die is geschreven door verschillende teams. Met het Git samenvoegen commando kun je je huidige ontwikkelingsbranch (die je hebt afgeleid van de hoofdbranch) nemen en de code wijzigingen samenvoegen terug in de hoofdbranch.
Git samenvoegen is een commando dat je het meest zult gebruiken wanneer je in een team werkt. Er kunnen momenten zijn waarop jij en een andere ontwikkelaar misschien samenwerken aan één functie op twee verschillende branches. Echter, wanneer de tijd daar is, zul je je werk moeten combineren in één branch, die wijzigingen moeten testen en vervolgens je gezamenlijke ontwikkeling samenvoegen in de hoofdontwikkelingsbranch.
Aangezien de hoofdontwikkelings-tak wordt bijgewerkt, zal de aparte functie-tak waar jij en andere ontwikkelaars aan werken niet worden bijgewerkt met de veranderingen van jouw team. Daarom is het gebruikelijk om, wanneer het tijd is om een pull-aanvraag in te dienen, altijd te beginnen met het bijwerken van je lokale versie van de hoofdtak met de laatste wijzigingen. Vervolgens kun je de bijgewerkte hoofdtak samenvoegen met jouw ontwikkelings-tak voordat je deze commit en een pull-aanvraag indient om deze samen te voegen in de hoofdontwikkelingstak.
Hoe twee Git-takken samenvoegen met Git merge
Als ontwikkelaar kan het beheersen van Git je echt helpen om productiever te zijn. Om te beginnen is het fundamenteel om te begrijpen hoe je Git-commando’s vanaf de opdrachtregel kunt uitvoeren. Voordat we beginnen, laten we eens bekijken wat je eerst moet instellen voordat je kunt beginnen met het samenvoegen van verschillende Git-takken.
Vereisten
Om te beginnen heb je de volgende items nodig:
- A Windows, Mac, or Linux machine to run Git.
- De Git-app, die beschikbaar is om hier te downloaden.
- A GitHub or Gitlab account.
- Code bewerkingssoftware zoals Visual Studio Code.
Laten we snel de verschillende stappen doornemen die nodig zijn om Git te installeren op een Windows pc (we hebben ook een aparte handleiding over hoe Git te installeren op Ubuntu):
- Volg de link om Git voor uw machine te downloaden en installeer de bestanden.
- Zodra geïnstalleerd, opent u uw terminal en typt u git –versie:
git –version
Als u een versienummer terugkrijgt, geweldig! Als u echter een “commando niet gevonden” bericht krijgt, moet u Git mogelijk toevoegen aan uw $PATH variabele. Dit is meestal een Windows probleem.
Laten we dat snel verhelpen, zodat u niet hoeft te blijven zoeken.
- Ga naar de Startbalk en klik met de rechtermuisknop op Deze pc.
- Selecteer Eigenschappen.
- Klik op Geavanceerde systeeminstellingen.
- Onder Systeemeigenschappen, klik op Omgevingsvariabelen. Hier kunt u waarden toevoegen aan de $PATH variabele.
- Selecteer $PATH en klik op Bewerken.
- Klik op Nieuw en voeg een pad toe naar git/cmd.
- Klik op Nieuw en voeg het pad naar het git.exe-bestand toe.
Sla de wijzigingen op, ga terug naar de terminal en voer het git -versie commando opnieuw uit.
git -version
Je zou nu het versienummer moeten zien. Na het voorwerk te hebben gedaan en je GitHub- of Gitlab-account te hebben ingesteld, zou je nu operationeel moeten zijn.
Een Git-project maken
In dit gedeelte zal ik je begeleiden bij de verschillende stappen die nodig zijn voor het maken van een nieuw repository.
Op je nieuw gecreëerde Github-account, klik op Nieuw aan de linkerkant van het scherm.
Vervolgens moet je je repository een naam geven en een paar andere gegevens invullen. Geef het een korte beschrijving als je wilt, maak het openbaar en een goede praktijk is altijd een ReadMe-bestand toe te voegen. Klik als je klaar bent op Repository aanmaken.
Om aan de slag te gaan in je code-editor, wil je je nieuwe repository klonen door op de Kloon knop te klikken. Selecteer HTTPS, kopieer het adres en open je terminal.
In je terminal, gebruik het cd commando om te kiezen waar je een nieuwe map voor je project wilt maken.
cd user/desktop/repo/
Wanneer je in de juiste branch bent, gebruik de mkdir commando om een nieuwe map te maken:
mkdir <name of your directory>
Nu, laten we opnieuw het cd commando gebruiken om naar die nieuw gemaakte map te navigeren:
cd <name of your newly created directory>
Eenmaal in je nieuwe map, gebruik het git init commando om een nieuw repository te maken:
git init
Vervolgens, gebruik het git clone commando met het juiste HTTPS-adres, en druk op Enter. Standaard wordt hiermee een hoofdbranch aangemaakt in je lokale repository.
git clone <paste https address here>
Open nu je zojuist gekloonde repository met Visual Studio Code. Je kunt nu beginnen met coderen.
Nadat je jouw repository hebt aangemaakt, bevind je je al op de hoofdbranch. Als goede gewoonte, zou je nooit direct code naar de hoofdbranch moeten pushen, deze dient beschermd te worden.
Voor deze zelfstudie zullen we niet ingaan op beveiligde Git-takken. Maar in de praktijk zul je nooit code naar de hoofdtak kunnen pushen zonder een pull-verzoek.
Het maken van een andere Git-tak
We bevinden ons momenteel op de hoofdtak, je hebt iets gecodeerd om wat inhoud te maken, en nu wil je een nieuwe tak maken.
Gebruik in je terminal het git checkout-commando om een nieuwe tak te maken en er automatisch naartoe te schakelen:
git checkout -b <name of new branch>
Het commando zou automatisch die nieuwe tak moeten afsplitsen van je hoofdtak, dus de code van laatstgenoemde mag niet veranderen.
En nu komt het leuke gedeelte waarbij we het git merge-commando kunnen gebruiken. Op je zojuist gecreëerde tak zul je eerst meer code moeten toevoegen zodat je huidige tak voorloopt op de hoofdtak met enkele nieuwe veranderingen.
Nu je deze nieuwe tak in de hoofdtak wilt samenvoegen, kun je een samenvoegconflict tegenkomen, wat een conflict van code-invoegingen is die in strijd zijn met code die al bestaat. Het is echt niet leuk om hiermee om te gaan.
Wat doe je? Laten we zien hoe je de ene branch samenvoegt met de andere.
Samenvoegen van je twee Git branches in je lokale repository
Terwijl je op je nieuwe branch bent, ga naar je terminal en gebruik het git branch commando om de naam van de branch te verifiëren waar je je op bevindt:
git branch
Je bent nu op je nieuwe branch, gebruik het git checkout commando opnieuw om terug te schakelen naar je hoofdbranch:
git checkout Main
Vervolgens, gebruik het git pull commando om eventuele wijzigingen die je team heeft aangebracht te importeren en je lokale hoofdbranch up-to-date te krijgen:
git pull
Gebruik nu weer git checkout om over te schakelen naar de nieuwe branch die je wilt samenvoegen met de hoofdbranch:
git checkout <your specified branch>
Het is nu tijd om het git merge commando te gebruiken. Dit zal de huidige versie van je hoofdbranch nemen en deze samenvoegen met je ontwikkelingsbranch:
git merge Main
Het samengevoegde resultaat zal de nieuwste versie van de code bevatten plus de functie die je hebt ontwikkeld.
Andere manieren om Git branches samen te voegen
Na je te hebben laten zien hoe je een nieuwe branch kunt samenvoegen met onze hoofdbranch, laten we eens kijken naar andere manieren om Git branches samen te voegen die je mogelijk moet gebruiken.
Wat is een snel-vooruit-samenvoeging?
A fast-forward merge is another way to merge multiple commits on one branch with one command rather than merging them all manually. Another advantage of using a fast-forward merge is that it will combine the histories of multiple commits while squashing the commit history.
Laten we aannemen dat we één functietak hebben die voorloopt op de hoofdtak door verschillende commits. We willen al deze commits samenvoegen zonder ze één voor één handmatig samen te voegen. In dit geval zullen we een fast-forward merge gebruiken.
In ons voorbeeld zullen we beginnen met het schrijven van wat code en het toevoegen van een nieuwe commit aan onze tak met de git add en git commit commando’s:
git add <filename>
git commit –m “added a thing”
Nu zullen we nog een commit toevoegen aan onze nieuwe tak door nogmaals dezelfde commando’s te gebruiken:
git add <filename>
git commit –m “added another thing”
Vervolgens willen we deze twee commits naar onze externe repository pushen zonder twee pushes te hoeven doen. Om dit te doen, moeten we de -ff optie gebruiken bij het git merge commando
git merge --ff
Dit zal beide commits tegelijk samenvoegen tot één en ervoor zorgen dat je code gelijk loopt met de hoofdtak.
Wat is een 3-way merge?
Stel je een situatie voor waarin je ontwikkelingsteam wat nieuwe functies heeft gecreëerd op twee aparte takken. Je staat nu klaar om de takken bij te werken en samen te voegen in de hoofdtak zodat deze laatste gereed is om code naar een externe repository te pushen.
Om ervoor te zorgen dat nieuwe functies correct samenwerken, is het een goed idee om de functietakken met elkaar samen te voegen en dan wat tests uit te voeren. Een 3-way merge stelt ons in staat om twee aparte takken samen te voegen met hun gemeenschappelijke voorouder.
Laten we de stappen doornemen die nodig zijn om een 3-way merge naar de doelbranch uit te voeren. In het onderstaande voorbeeld zullen we beginnen met het maken van een nieuwe branch, twee commits toevoegen en deze combineren met onze hoofdbranch met behulp van een 3-way merge.
Eerst maken we een ‘new-feature’ branch en schakelen er automatisch naar over met het git checkout commando. Door -b te specificeren bij dit commando wordt een nieuwe branch aangemaakt:
git checkout -b new-feature main
Vervolgens voegen we wat bestanden toe en maken een nieuwe commit aan onze branch met de volgende commando’s:
git add <file>
git commit -m "Start a feature"
Vervolgens voegen we nog een commit toe aan onze nieuwe branch met de volgende commando’s:
git add <file>
git commit -m "Finish a feature"
Nadat we nieuwe code aan onze nieuwe branch hebben toegevoegd, moet je je voorstellen dat onze hoofdbranch ook blijft evolueren. We schakelen eerst terug naar de hoofdbranch met het git checkout commando:
git checkout main
Vervolgens voegen we een nieuwe commit toe aan onze hoofdbranch:
git add <file>
git commit -m "make some changes to Main"
Nu willen we de ‘new-feature’ branch die we eerder hebben gemaakt samenvoegen met onze bijgewerkte hoofdbranch. Aangezien er nog steeds werk zal plaatsvinden op onze hoofdbranch, zullen we eindigen door de ‘new-feature’ branch te verwijderen met het git branch commando.
git merge new-feature
git branch -d new-feature
Nu hebben we onze twee branches samengevoegd met een gemeenschappelijke voorouder in onze hoofdbranch. Deze laatste is nu klaar om samengevoegd te worden met je externe repository en verdere vooruitgang te boeken in ons softwareproject, en we zullen zien hoe we dat kunnen doen.
Hoe een Git branch samenvoegen met een externe repository
Soms moet je een tak samenvoegen in een externe repository. Laten we de stappen doornemen over hoe je dat kunt bereiken.
Laten we ons een situatie voorstellen waarin je nieuwe code hebt geschreven voor een nieuwe functie die je producteigenaar wilde maken. Na het testen van je code en het doornemen ervan met je producteigenaar, ben je nu klaar om je harde werk samen te voegen in de externe repository van je team.
Zoals eerder vermeld, moet je nooit in staat zijn om je code rechtstreeks naar de hoofdtak te pushen. Je moet altijd het Git-workflow respecteren die we aan het begin van deze gids hebben gedetailleerd.
Na het doornemen van het Git-proces, laten we je code samenvoegen. We gaan verder waar we gebleven waren, we hebben nu een up-to-date tak: De laatste updates van de hoofdtak zijn naar beneden gehaald naar je lokale repository.
Je staat nu voor de poorten van de externe repository. Hoe kom je daar? Simpel, we gaan wat meer git-commando’s gebruiken.
Als goede praktijk moet je altijd de status van je tak controleren met het git status-commando. Dit commando laat zien welke bestanden zijn toegevoegd, verwijderd, gevolgd of ongevolgd zijn.
git status
Je moet ook controleren of je bestanden hebt toegevoegd die ongevolgd zijn. In dat geval moet je ze toevoegen zodat ze gevolgd worden en aan de commit worden toegevoegd.
Je kunt het git add commando gebruiken om alle bestanden toe te voegen die je hebt gemaakt in je ontwikkeling. Nu moet je misschien enkele bestandsnamen uitschrijven als je alleen specifieke bestanden wilt toevoegen. Als je alle bestanden wilt toevoegen, gebruik dan “.” om alle bestanden toe te voegen.
Vervolgens zullen we het git commit commando gebruiken om alle bestanden te committen die we in de vorige stap hebben toegevoegd. Je moet de -m vlag gebruiken om een bericht te schrijven, anders kom je in de teksteditor modus terecht om een bericht te schrijven, wat geen gestroomlijnd proces is.
Voor je bericht kun je een korte notitie schrijven over wat je hebt gedaan. Bijvoorbeeld, “een nieuwe coole functie gemaakt en een nieuw pictogram aan het menu toegevoegd en bugfixes toegevoegd.”
git commit -m “<your commit message goes here>”
Tenslotte kun je het git push commando gebruiken om je branch naar het externe repository te pushen.
git push --set-upstream origin <<your branch name>>
Nu, na het pushen van je branch, moet je naar GitHub gaan of waar je externe repositories worden gehost, je meest recente push vinden en klikken op Create pull request.
Zodra je op deze knop klikt, word je naar een pagina gebracht om reviewers en leden van je team toe te voegen die je mergeverzoek zullen goedkeuren of afkeuren. In het tweede geval kunnen ze opmerkingen toevoegen over wat er moet worden aangepast voordat je je branch kunt samenvoegen in de externe hoofdbranch.
Zodra de review is voltooid en je merge-verzoek is goedgekeurd, zal de Samenvoegen-knop beschikbaar zijn. Klik op deze knop om de samenvoeging te starten. Als de samenvoeging succesvol is, ontvang je een bericht waarin wordt bevestigd dat je nieuwe code is toegevoegd.
Gefeliciteerd! Je hebt de basis onder de knie voor het gebruik van het git merge-commando!
Conclusie
Git merge is een krachtig commando waarmee jij en je team verschillende branches kunnen gebruiken om aan nieuwe functies te werken, en ze vervolgens samen te voegen naar je hoofdrepository.
Je hebt de juiste stappen geleerd die nodig zijn om branches te maken, ze samen te voegen, bestanden en commits eraan toe te voegen, en het belangrijkste, die branches naar een externe repository te pushen. Bovendien begrijp je nu hoe je een fast-forward merge moet uitvoeren om verschillende gerelateerde branches te combineren met één commando, wat echt kan helpen om elk ontwikkelingswerk efficiënter te maken.
Git is een krachtige tool die veel kan. Hoe meer je leert over de verschillende commando’s die je kunt gebruiken, hoe beter je wordt als ontwikkelaar. Nu je alles hebt geleerd wat je moet weten over het samenvoegen van branches, is het tijd om andere commando’s te leren. Veel succes met je zoektocht om Git onder de knie te krijgen!