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 av sammenslåing av grener
I Git er **sammenslåing** prosessen med å integrere endringer fra én gren inn i en annen. Den vanligste bruken er å slå sammen **feature**-grener inn i **main**-grenen (for eksempel `main` eller `master`). Dette sikrer at de nyeste funksjonene og feilrettingene blir inkludert i hovedkodebasen.


## Grunnleggende arbeidsflyt for sammenslåing

Vis først de to siste commitene.
Husk at du for øyeblikket er på `feature/new-feature`-grenen.
```
git log -n 2
```

Som du kan se, er `master`-grenen én commit **bak**.
Før du slår sammen, må du **bytte** til grenen der endringene skal integreres.
Bytt til `master`-grenen og vis de to siste commitene på den:
```
git checkout master
```

Branchen `master` ligger faktisk én commit bak **feature**-branchen.
For å slå dem sammen, bruk kommandoen `git merge` og spesifiser hvilken branch som skal flettes inn i den **nåværende** branchen.
For eksempel, for å flette `feature/new-feature`-branchen inn i `master`, kjør:
```
git merge feature/new-feature
```

Meldingen som vises etter at kommandoen er kjørt inneholder følgende: `Fast-forward`, som angir at en **fast-forward**-fletting ble utført.


Merk

Du vil utforske de to typene sammenslåinger senere i dette kapittelet.
Før det, se på de to siste commitene:
```
git log -n 2
```

Du er fortsatt på `master`-grenen, men den er nå oppdatert med **feature**-grenen, og **begge** grenene peker til samme commit.


**HEAD** peker fortsatt til `master`-grenen fordi du befant deg på denne grenen da du utførte sammenslåingen.


## Sammenslåingstyper

Det finnes to typer sammenslåingsoperasjoner i Git:

* **Fast-forward-sammenslåing**;
* **Treveis-sammenslåing**.

### Fast-forward-sammenslåing

Sammenslåingen du utførte er en **fast-forward**-sammenslåing, som angitt i meldingen.
Denne typen oppstår når **alle** commitene fra den nåværende utsjekkede grenen også finnes i grenen som slås sammen, noe som betyr at commit-historikkene **ikke har forgreininger**.

Se illustrasjonen nedenfor for en forklaring:


Med denne typen sammenslåing blir pekeren til den utsjekkede grenen ganske enkelt oppdatert til den siste commit-en.


### Treveis sammenslåing
Hvis historikken til grenene har **delt seg**, det vil si at det etter en felles commit har blitt gjort nye commit-er separat på hver gren, utføres en **treveis** sammenslåing.

Begrepet "treveis" refererer til de **tre versjonene** som er involvert i sammenslåingen:

* Versjonen til den **nyeste felles forfaderen** (commit);
* Versjonen til den siste commit-en i den nåværende grenen (**HEAD**);
* Versjonen til den **siste commit-en** i grenen som slås sammen.

Se på følgende illustrasjon av denne typen sammenslåing:


Slik fungerer en treveisfletting:

1. Git identifiserer endringene som er gjort på hver av grenene etter **den siste felles forfaderen**;
2. Hvis hver gren har endringer i ulike filer eller ulike deler av samme fil, vil Git **automatisk** flette endringene ved å kombinere dem i den resulterende commiten;
3. Ellers vil det oppstå en **flettekonflikt**.



Git er det mest populære versjonskontrollsystemet brukt av millioner av utviklere over hele verden. Enten du er en erfaren utvikler eller nybegynner, vil dette kurset gi deg kunnskapen og ferdighetene du trenger for å effektivt håndtere programvareprosjektene dine, samarbeide med andre og mestre kunsten av versjonskontroll.

Først gir vi en oversikt over versjonskontrollsystemer generelt. Deretter diskuterer vi Git og lærer det grunnleggende om å opprette et depot og gjøre endringer i det.

Nå er det på tide å gå gjennom mer avansert samhandling med Git, noe som vil øke effektiviteten din og gjøre deg mer fortrolig med noen av de vanlige Git-arbeidsflytene.

Som et versjonskontrollsystem gir Git deg muligheten til å angre endringer ved behov. Nå er det på tide å utforske teknikker i Git for å tilbakestille ikke-stagede endringer i arbeidsområdet, stagede endringer og til og med tilbakestille eller overskrive commits.

Grener i Git er svært nyttige ved samarbeid med andre, feilretting eller utvikling av spesifikke funksjoner i prosjektet ditt. Uten videre introduksjon, la oss utforske alle nyansene ved å arbeide med grener.

Slå Sammen Grener

Forståelse av sammenslåing av grener

Grunnleggende arbeidsflyt for sammenslåing

Sammenslåingstyper

Fast-forward-sammenslåing

Treveis sammenslåing