Summary  
This chapter explains how to merge code branches in Git, detailing fast-forward and three-way merge strategies for integrating divergent commit histories and resolving conflicts.

General domain of usage  
Version control

## Forståelse af sammenfletning af grene
I Git er **sammenfletning** processen, hvor ændringer fra én gren integreres i en anden. Den mest almindelige anvendelse er at sammenflette **feature**-grene ind i **main**-grenen (f.eks. `main` eller `master`). Dette sikrer, at de nyeste funktioner og fejlrettelser bliver en del af hovedkodebasen.


## Grundlæggende arbejdsgang for sammenfletning

Start med at se de to seneste commits.
Bemærk, at du aktuelt befinder dig på `feature/new-feature`-grenen.
```
git log -n 2
```

Som du kan se, er `master`-grenen ét commit **bagud**.
Før du sammenfletter, skal du **skifte** til den gren, hvor ændringerne skal integreres.
Skift til `master`-grenen og vis de to seneste commits på den:
```
git checkout master
```

`master`-grenen er faktisk ét commit bagud i forhold til **feature**-grenen.
For at flette dem, brug kommandoen `git merge` og angiv den gren, der skal flettes ind i den **aktuelle** gren.
For eksempel, for at flette `feature/new-feature`-grenen ind i `master`, kør:
```
git merge feature/new-feature
```

Beskeden, der vises efter at have kørt kommandoen, indeholder følgende: `Fast-forward`, hvilket angiver, at en **fast-forward**-fletning blev udført.


Bemærk

Du vil udforske de to typer af sammenfletninger senere i dette kapitel.
Inden da, se de to seneste commits:
```
git log -n 2
```

Du er stadig på `master`-grenen, men den er nu opdateret med **feature**-grenen, hvor **begge** grene peger på det samme commit.


**HEAD** peger stadig på `master`-grenen, fordi du var på denne gren, da du udførte sammenfletningen.


## Fletningstyper

Der findes to typer fletteoperationer i Git:

* **Fast-forward-fletning**;
* **Trevejsfletning**.

### Fast-forward-fletning

Den fletning, du udførte, er en **fast-forward**-fletning, som angivet i beskeden.
Denne type opstår, når **alle** commits fra den aktuelt udtjekkede gren også findes i den gren, der flettes ind, hvilket betyder, at deres commit-historik **ikke afviger**.

Se følgende illustration for en præcisering:


Med denne type fletning opdateres markøren for den udtjekkede gren blot til det seneste commit.


### Trevejsfletning 
Hvis grenens historik derimod er **afveget**, hvilket betyder, at der efter et fælles commit er blevet lavet nye commits separat på hver gren, udføres der en **trevejsfletning**. 

Udtrykket "trevejs" henviser til de **tre versioner**, der indgår i fletningen:

* Versionen af den **seneste fælles forfader** (commit);
* Versionen af det seneste commit på den aktuelle gren (**HEAD**); 
* Versionen af det **seneste commit** på den gren, der flettes ind.

Se følgende illustration af denne type fletning:


Sådan fungerer en trevejsfletning:

1. Git identificerer de ændringer, der er foretaget på hver af grenene efter den **seneste fælles forfader**;
2. Hvis hver gren har ændringer i forskellige filer eller forskellige dele af den samme fil, vil Git **automatisk** flette ændringerne ved at kombinere dem i det resulterende commit;
3. Ellers vil der opstå en **fletningskonflikt**.



Git er det mest populære versionsstyringssystem, der bruges af millioner af udviklere verden over. Uanset om du er en erfaren udvikler eller nybegynder, vil dette kursus give dig den viden og de færdigheder, der er nødvendige for effektivt at administrere dine softwareprojekter, samarbejde med andre og mestre kunsten af versionsstyring.

Først giver vi et overblik over versionsstyringssystemer generelt. Derefter diskuterer vi Git og gennemgår det grundlæggende i at oprette et repository og foretage ændringer i det.

Nu er det tid til at gennemgå mere avanceret interaktion med Git, hvilket vil øge din effektivitet og gøre dig mere fortrolig med nogle af de almindelige Git-arbejdsgange.

Som et versionskontrolsystem giver Git dig mulighed for at fortryde ændringer efter behov, så det er tid til at udforske teknikkerne i Git til at tilbageføre ikke-staged ændringer i arbejdstræet, staged ændringer og endda tilbageføre eller overskrive commits.

Grener i Git er yderst nyttige ved samarbejde med andre, fejlretning eller udvikling af specifikke funktioner i et projekt. Uden yderligere introduktion gennemgås nu alle nuancer ved arbejde med grener.

Fletning af Grene

Forståelse af sammenfletning af grene

Grundlæggende arbejdsgang for sammenfletning

Fletningstyper

Fast-forward-fletning

Trevejsfletning