Lektioner i Git: sammanfoga / rebase

Det distribuerade versionskontrollsystemet som kallas Git har förändrat hur utvecklare tänker på kodkoppling och förgrening, jämfört med de tidigare versionskontrollsystemen som CVS och SVN.


Med Git blev dessa operationer relativt enkla och snabba att göra. Detta system gör det möjligt för utvecklare att skapa nya funktioner isolerade från huvudgrenen och integrera dem vid en senare tidpunkt när funktionen är redo för integration.

Om du är ny på Git bör följande länkar hjälpa dig att komma igång snabbt:

  • Git – The Simple Guide
  • Git Basics
  • Git grenar grunderna
  • En framgångsrik Git-filialmodell

I Git finns det två huvudsakliga sätt att integrera förändringar från en gren till en annan:

  1. sammanfoga
  2. omviktningen

Vi kommer att titta på sammanslagning med -ff-alternativet och –no-ff-alternativet. Obs! Det finns inget git –no-ff rebase-kommando.

En snabb demonstrationsinställning

Innan vi tittar på de två sätten att slå samman, låt oss först skapa ett fungerande Git-arkiv med följande kommandon:

1
2
3
4
5
6

mkdir mycode

echo “foo bar baz” > mycode / foo.txt

git init mycode

cd mycode

git lägg foo.txt

git commit -m “Commit meddelande”

Låt oss nu skapa en ny gren med namnet “myfeature” och växla till den:

1 git checkout -b myfeature

Nu kan vi göra en ändring av “foo.txt” -filen i “myfeature” -grenen i vår lokala repo:

1
2

echo -e “foo bar baznquux” > foo.txt

git commit -a -m ‘lagt till min funktion’

Låt oss anta att vår “myfeature” -ändring är klar, och nu vill vi integrera den här funktionen i vår “master” -gren.

Vår git-graf skulle se ut så här:

1
2
3

   B min funktion

  /

En mästare

Som nämnts tidigare om Git, har vi två sätt att göra detta: antingen genom att göra en sammanslagning eller en rebase.

Hur man använder: git merge

Git-merge-kommandot förenar två eller flera grenar tillsammans.

Först låt oss byta tillbaka till “mästaren” så att vi kan tillämpa sammanslagningen på vår huvudgren.

1 git checkout master

Vi kan nu göra sammanslagningen, men låt oss först diskutera de två olika sätten att skapa en sammanslagning.

Ofta är det nuvarande grenhuvudet en förfader till det namngivna engagemanget (“myfeature”). Detta är det vanligaste fallet. I det här scenariot behövs inte ett nytt åtagande för att lagra den kombinerade historiken. Istället uppdateras git HEAD (tillsammans med indexet) så att det pekar på det namngivna engagemanget utan att skapa en extra sammanslagningsåtagande.

Git-sammanslagningens standardbeteende är att göra en snabbspolning när det är möjligt. Detta standardbeteende kan göras uttryckligt med alternativet -ff, eller detta beteende kan undertrycks med alternativet no-fast-forward merge (–no-ff). Vid sammanslagning av en annoterad tagg skapar Git alltid en sammanslagningskombination även om en snabbspolning är möjlig.

När du använder –no-ff kan någon som granskar githistoriken tydligt se den gren du checkade ut för att arbeta med. Observera också hur –no-ff-sammanslagningen har en extra sammanslagningskombination i slutet.

Nedan visas en bild som visar skillnaden mellan en –no-ff och -ff-sammanslagning.

git - no-ff rebase

Så du har nu möjligheten att använda endera av:

1 git slå samman min funktion

Efter det här kommandot ser vår git-graf ut så här:

1 A – B-mästare

Eller så kan vi behålla grenhistorien genom att göra:

1 git merge – no-ff myfeature

I det senare fallet skulle vår git-graf nu se ut så här:

1
2
3

  B min funktion

/

A – C-mästare

Och om vi kör följande git-loggkommando:

1 git log –graf – full-historia – all – pretty = format: “% h% x09% d% x20% s”

Detta visar en liknande git-graf:

1
2
3
4
5

* 5368727 (HEAD, master) Slå samman gren “myfeature”

|

| * 6267227 (myfeature) har lagt till myfeature

| /

* ac54e38 Kommittémeddelande

Vilken typ av sammanslagning du föredrar beror på hur mycket av filialinformationen du vill lagra när du går samman.

Hur man använder: git rebase

Det andra sättet att integrera förändringar från en gren till en annan är att göra en git rebase.

När sammanslagning förenar två grenar samtidigt som grafen för varje åtagningshistorik bevaras, förenar du grenarna igen genom att skriva om ändringar från källgrenen så att de visas som barn i destinationsgrenen.

Git-omklassningen framåt-portar lokalt återställer det uppdaterade uppströmshuvudet. Omplacering är processen att flytta en filial till en ny basåtagande.

Så här ser det ut i en git-graf. Anta att följande historia finns och den nuvarande grenen är “myfeature”:

1
2
3

      A – B – C myfeature

     /

D – E – F – G-mästare

Och om vi nu gör:

1 git rebase master

Resultatet skulle bli:

1
2
3

        A´ – B’ – C ’myfeature

       /

D — E — F — G-mästare

“Master” -grenen innehåller nu “myfeature” -grenen som ändras vid engagemang “G” utan att skapa en fusionsåtagande. Så istället för att gå samman med grenarna med en sammanslagningskombination integrerar omfasningen “myfeature” grenen genom att bygga ovanpå mästaren. Resultatet är en linjär historia som kan vara lättare att förstå för utvecklare. Git-loggen skulle nu visa den linjära historien om “D-E-F-G-master”.

I händelse av konflikt kommer git-rebas att stanna vid den första problematiska begåendet och lämna konfliktmarkörer i trädet.

Slå samman eller återföra?

Båda metoderna för kodintegrering bör användas när de passar bäst. Det finns olika åsikter om när en viss metod ska användas.

Här är några länkar som beskriver situationer när en metod kan vara att föredra framför den andra:

  • smälta samman eller rebasera?
  • När ska man smälta mot när du ska rebasera
  • Git Team-arbetsflöden: slå samman eller omklassificera?
Jeffrey Wilson Administrator
Sorry! The Author has not filled his profile.
follow me
    Adblock
    detector