Git Merge Vereenvoudigd: Branches Samenvoegen Als een Professional – techsyncer

Het samenvoegen van branches in Git kan soms een ontmoedigende taak zijn, maar het git merge-commando vereenvoudigt het proces aanzienlijk. In deze tutorial leer je de essentie van het combineren van branches met behulp van git merge, in combinatie met GitHub, een toonaangevende projectbeheertool.

Laten we beginnen aan deze reis in de wereld van Git en GitHub, met de nadruk op het krachtige git merge-commando.

Vereisten voor het beheersen van Git Merge

Voordat je je verdiept in de complexiteiten van git merge, zorg ervoor dat je de volgende setup hebt:

Git (Versie 2.25.1 gebruikt in deze tutorial) – Download vanaf de officiële site van Git.
A GitHub account – Sign up at GitHub.
Een Ubuntu-machine (Ubuntu 20.04 wordt hier gebruikt, maar elk besturingssysteem met Git is voldoende).

Het initialiseren van een project voor Git Merge

Om git merge effectief te kunnen gebruiken, heb je eerst een Git-project nodig. Laten we een demoproject opzetten voor oefening.

1. Begin door een nieuwe map genaamd ~/git-demo te maken en erin te navigeren:

mkdir git-demo && cd git-demo

2. Maak een index.html-bestand in de map ~/git-demo met de volgende inhoud. Dit basis-HTML-bestand geeft een bericht weer over het beginnen met git merge.

<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Git Merge Demo</title>
</head>
<body>
    <h4>Let's get started with git merge</h4>
</body>
</html>

3. Initialiseer een nieuw Git-repository in je projectdirectory:

De git init-opdracht wordt gebruikt om een bestaand, niet-geversioneerd project om te zetten in een Git-opslagplaats of om een nieuw project te starten met Git.

git init

Initializing a Git repository for git merge

4. Bevestig de creatie van de .git-map in je projectdirectory. In deze map houdt Git wijzigingen bij:

ls -la

Verifying the existence of the GIT repository in the directory.

5. Voer de git add-opdracht uit om je wijzigingen in het project te stagen. Door het index.html-bestand te stagen, bereid je het voor op de volgende commit in de Git-workflow.

git add index.html

6. Gebruik git status om te bevestigen dat je bestand correct is gestaged. Deze opdracht geeft een momentopname van de huidige staat van je werkdirectory.

git status

Confirming the staging of changes for git merge.

7. Commit vervolgens je wijzigingen met git commit. Deze opdracht slaat je gestagede wijzigingen op in de lokale repository en markeert een belangrijke stap in je versiegeschiedenis.

git commit -m "initial commit"

Executing the initial commit in preparation for git merge.

Stel je Git-identiteit in met: git config --global user.email "[email protected]" en git config --global user.name "Your Name" als je Git voor de eerste keer gebruikt.

8. Bekijk je commitgeschiedenis met git log. Deze opdracht helpt je wijzigingen bij te houden en is essentieel bij het voorbereiden van een git merge.

git log

Checking commit history before performing git merge.

9. Bevestig het bestaan van branches in je repository met git branch. Deze stap is cruciaal voordat je een git merge uitvoert.

Opmerking: De standaardbranch heeft in recente Git-versies de naam ‘main’, ter vervanging van ‘master’.

git branch

Listing all branches in preparation for git merge.

Aanmaken van een Branch voor Git Merge

Met uw initiële Git-setup voltooid en de eerste commit gemaakt, is het tijd om een nieuwe branch te maken. Deze branch zal worden gebruikt om het git merge-proces effectief te demonstreren.

1. Werk het index.html-bestand bij met nieuwe inhoud om wijzigingen in uw branch te demonstreren. Deze versie bevat gebruikersinvoervelden en bereidt zich voor op een demonstratie van git merge.

<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Git Merge Demo</title>
</head>
<body>
    <h4>Enhancing Git Merge Skills</h4>
    <form action="">
      <input type="text" name="username" placeholder="Username" />
      <input type="password" name="password" placeholder="Password" />
    </form>
</body>
</html>

2. Controleer de status van uw repository met git status om de wijzigingen in index.html te bekijken. Het zou moeten aangeven dat het bestand is gewijzigd en niet gestaged, klaar voor de volgende stappen in het git merge-proces.

Inspecting repository changes for git merge.

3. Maak een nieuwe branch met de naam “form” met git checkout -b form. Deze opdracht maakt niet alleen de nieuwe branch aan, maar schakelt ook uw werkende branch over naar “form”, essentieel voor de implementatie van git merge.

git checkout -b form

4. Bevestig de creatie van de nieuwe branch door git branch uit te voeren. U zou nu zowel de “form” als de “master” branches moeten zien, waarbij “form” de actieve branch is die wordt aangegeven met een asterisk (*).

git branch

Confirming the active ‘form’ branch for git merge.

5. Stel uw wijzigingen op de form-branch en commit deze. Deze actie zorgt ervoor dat de form-branch de recente updates weerspiegelt die zijn gemaakt in het index.html-bestand, wat de weg vrijmaakt voor een effectieve git merge.

## Bestand bijwerken in de staging-fase
git add index.html

## Commit de nieuwe wijzigingen
git commit -m "Added user input fields to form"

Committing updated index.html to the ‘form’ branch for git merge.

Lokale Branch-samenvoeging met Git Merge

Nu je verschillende branches hebt in je GitHub-repository, is de volgende stap om ze samen te voegen. Deze sectie richt zich op het lokaal samenvoegen van branches met behulp van het git merge-commando, een fundamentele Git-operatie.

1. Om de samenvoeging te starten, schakel over naar de master-branch, die de updates van de form-branch zal ontvangen:

git checkout master

2. Eenmaal op de master-branch, voer git merge form uit om de wijzigingen van de form-branch samen te voegen in master. Dit is een cruciale stap in het git merge-proces.

git merge form

Successfully merging branches using `git merge`.

3. Bevestig de samenvoeging door ervoor te zorgen dat je op de master-branch bent en controleer of de inhoud van index.html is bijgewerkt.

# Bevestig huidige branch
git branch
# Controleer samengevoegde inhoud
cat index.html

Reviewing *index.html* content post `git merge`.

Optimaliseren met Git Squash

Squashen in Git is een techniek die wordt gebruikt om de commit-geschiedenis op te schonen. Wanneer je meerdere commit-berichten hebt die individueel niet nodig zijn, stelt squashen je in staat om deze samen te voegen tot één alomvattende commit. Deze praktijk is vooral handig bij het voorbereiden van een git merge.

Laten we het squash-proces verkennen door verdere wijzigingen aan te brengen in het index.html-bestand op de form-branch en deze wijzigingen vervolgens samen te voegen.

1. Schakel terug naar de formulier-tak om extra wijzigingen aan te brengen:

git checkout form

2. Pas het bestand index.html aan door een formulierkop toe te voegen. Deze stap zal een wijziging creëren die we later zullen samenvoegen tijdens de merge:

<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    <h4>Mastering Git Merge with Form Updates</h4>
    <form action="">
      <h4>Account Details</h4>
      <input type="text" name="username" placeholder="Username" />
      <input type="password" name="password" placeholder="Password" />
      <button>Submit</button>
    </form>
</body>
</html>

3. Stel de wijzigingen op het podium en commit ze met een duidelijke boodschap die de update beschrijft:

git add index.html
git commit -m "Enhanced form with a header for git merge"

Staging and committing changes for squashing in `git merge`.

4. Verbeter het bestand index.html in de formulier-tak door een nieuw invoerveld toe te voegen. Deze wijziging maakt deel uit van de voorbereiding op een effectieve git merge.

<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Git Merge Example</title>
</head>
<body>
    <h4>Practicing Git Merge</h4>
    <form action="">
      <h4>Enter account details</h4>
      <input type="text" name="fullname" placeholder="Full Name" />
      <input type="text" name="username" placeholder="Username" />
      <input type="password" name="password" placeholder="Password" />
      <button>Submit</button>
    </form>
</body>
</html>

5. Stel deze wijzigingen op het podium en commit ze met een duidelijke boodschap, waarbij elke stap in je werk duidelijk gedocumenteerd is voor de komende git merge.

git add index.html
git commit -m "Enhanced form with an additional input field"

Adding another input field to index.html for `git merge`.

6. Voeg vervolgens een alinea-element toe onder het formulier in index.html, waarbij het bestand verder wordt aangepast ter voorbereiding op een git merge.

<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Git Merge Practice</title>
</head>
<body>
    <h4>Let's get started with git merge</h4>
    <form action="">
      <h4>Enter account details</h4>
      <input type="text" name="fullname" placeholder="Full Name" />
      <input type="text" name="username" placeholder="Username" />
      <input type="password" name="password" placeholder="Password" />
      <button>Submit</button>
    </form>
    <p>Already a user?</p>
</body>
</html>

7. Stel opnieuw de wijzigingen op het podium en commit ze, gebruikmakend van een boodschap die de essentie van deze update vastlegt, essentieel voor het git merge-proces.

git add index.html
git commit -m "Added user status paragraph to form"

Further modifying index.html for `git merge`.

8. Gebruik git rebase in de interactieve modus om je recente commits te bekijken en te bewerken. Deze stap is essentieel in het proces van het samenvoegen van commits voor een schone git merge.

git rebase -i HEAD~3

9. Kies in de interactieve modus ervoor om het eerste commitbericht te herschrijven en de daaropvolgende te samenvoegen. Deze actie consolideert je commitgeschiedenis, waardoor je git merge schoner en georganiseerder wordt.

Preparing commits for squashing in `git merge`.

10. Na het herschrijven en opslaan, werk het geconsolideerde commitbericht bij om de cumulatieve wijzigingen weer te geven. Deze stap finaliseert het samenvoegingsproces en bereidt je voor op een gestroomlijnde git merge.

Finalizing the commit message for `git merge`.

Bevestig het succes van je samendrukkingsoperatie, die een integraal onderdeel is van het git merge-proces bij het verwerken van meerdere commitberichten.

Voor gelijktijdig samendrukken en samenvoegen, gebruik git merge --squash. Met deze techniek worden de wijzigingen van de formulier-tak samengevoegd in de master-tak, waarbij de commits efficiënt worden gecombineerd.

git merge --squash form

Het uitvoeren van het git merge --squash-commando combineert de wijzigingen van de form-tak in master, waarbij alle commits worden samengevoegd tot één. Deze aanpak maakt deel uit van effectieve git merge-strategieën.

Executing `git merge` with squash option.

Implementatie van Fast-Forward in Git Merge

Voor een gestroomlijnde commitgeschiedenis is fast-forwarding een ideale methode, met name voor kleine updates of bugfixes. Het stelt je in staat takken samen te voegen zonder extra merge-commits, wat cruciaal is voor een schone en lineaire geschiedenis, essentieel voor efficiënte git merge-processen.

Fast-forwarding vindt plaats wanneer er geen divergentie is in de basis-tak, meestal de master, waardoor een naadloze integratie van geschiedenissen en pointer-updates mogelijk is.

1. Wissel naar de form-tak om het fast-forward-proces te starten:

git checkout form

2. Maak en werk een JavaScript-bestand bij, zoals index.js, in de form-tak, waarbij de wijzigingen worden gestaged en gecommit:

git add index.js
git commit -m "Added JavaScript functionality"

3. Tenslotte, voeg de form-tak samen in master met een fast-forward-benadering. Deze stap brengt de master-tak in lijn met de nieuwste wijzigingen van de form-tak, waardoor een soepele, lineaire git merge-route ontstaat.

git checkout master
git merge form

Conclusie

Deze tutorial heeft je door verschillende technieken geleid om branches te combineren met `git merge`. Van het samenvoegen van commits tot het snel vooruitgaan, deze methoden verbeteren je vermogen om projecten gezamenlijk te beheren in Git.

Nu je deze vaardigheden hebt, overweeg bij te dragen aan samenwerkingsprojecten op GitHub, waarbij je je kennis van `git merge` toepast in realistische scenario’s.