Git

Git Rebase-handledning

Git Rebase-handledning

Nybörjare av Git varnas mot kommandot rebase. Och med rätta. Med alla de nya sakerna att lära sig är nybörjare troligen bättre att behärska de grundläggande begreppen innan de gräver sig in i omständigheterna med omfördelning. Men om du förstår grunderna i att slå samman filialer, kan du hjälpa dig att lösa några komplicerade utvecklingspussel när rätt tid kommer att veta hur du ska basa om.

Git Rebase: Definitioner

Enligt git-dokumentationen kommer rebase-kommandot att återanvända åtar sig ovanpå en annan basspets. Denna definition kan vara lite skrämmande. Det är lättare att förklara rebase som ett förfarande som lägger till ändringarna av den aktuella grenen i en annan gren. Låt oss gå igenom ett exempel för att få en bättre uppfattning om vad som händer.

Git Rebasing Exempel

I det här exemplet skapar vi först ett testfall med 'master' och 'feature' gren. Då kommer vi att göra en standardfusion. Därefter kommer vi att återskapa testfallet och utföra omfördelning och sammanslagning.

1. Skapa master- och funktionsgrenar

Här är det scenario vi kommer att skapa:

A - B - C (master) \ E - F (funktion)

I exemplet ovan tar vi följande väg:

  1. Begå A: vi lägger till en.txt-fil i "master" -grenen
  1. Begå B: vi lägger till b.txt-fil i "master" -grenen
  1. I detta skede skapar vi filialens "funktion" vilket innebär att den kommer att ha en.txt och b.Text
  1. Begå C: vi lägger till c.txt-fil i "master" -grenen
  1. Vi går till "funktionsgrenen"
  1. Begå E: vi modifierar a.txt i 'funktionsgren'
  1. Begå F: vi modifierar b.txt i 'funktionsgren'

Du kan skapa en mapp och köra följande kod inuti mappen för att skapa ovanstående situation:

git init touch a.txt git add -A git commit -m "Commit A: lagt till a.txt "tryck b.txt git add -A git commit -m "Commit B: added b.txt "git gren funktion peka c.txt git add -A git commit -m "Commit C: added c.txt "git status git checkout funktion echo aaa> a.txt git add -A git commit -m "Commit E: modifierad a.txt "echo bbb> b.txt git add -A git commit -m "Commit F: modifierad b.Text"

2. Enkel sammanslagning

Låt oss använda loggkommandot för att kontrollera båda grenarna.

Resultat för 'master':

$ git checkout master Bytt till gren 'master' $ git log --oneline 2bbde47 Åtagande C: lagt till c.txt b430ab5 Åtagande B: tillagd b.txt 6f30e95 Åtagande A: lagt till a.txt $ ls a.txt b.txt c.Text

Resultat för 'feature':

$ git checkout-funktion Bytt till filialfunktion $ git-logg - online 0286690 Åtagande F: modifierad b.txt 7c5c85e Engagera E: modifierad a.txt b430ab5 Åtagande B: tillagd b.txt 6f30e95 Åtagande A: lagt till a.txt $ ls a.txt b.Text

Lägg märke till hur funktionsgrenen inte har Commit C

Låt oss nu köra sammanslagningsfunktionsfilial med "huvudfilial". Du kommer att bli ombedd att ange en kommentar. I kommentaren lägger du till "Commit G:" i början för att göra det lättare att spåra.

$ git checkout master Bytt till filial "master" $ git merge-funktion Slå samman med "rekursiv" strategi. a.txt | 1 + b.txt | 1 + 2 filer har ändrats, 2 infogningar (+)

Resultat för 'master':

 $ git checkout master Redan på 'master' $ git log --oneline d086ff9 Åtagande G: Slå samman filialfunktion '0286690 Åtgärd F: modifierad b.txt 7c5c85e Engagera E: modifierad a.txt 2bbde47 Åtgärd C: lagt till c.txt b430ab5 Åtagande B: tillagd b.txt 6f30e95 Åtagande A: lagt till a.txt $ ls a.txt b.txt c.Text

Resultat för 'feature':

$ git checkout-funktion Byt till filialfunktion $ git-logg - online 0286690 Åtagande F: modifierad b.txt 7c5c85e Engagera E: modifierad a.txt b430ab5 Åtagande B: tillagd b.txt 6f30e95 Åtagande A: lagt till a.txt $ ls a.txt b.Text

I "master" -grenen kommer du att märka att det finns ett nytt engagemang G som har sammanfört ändringarna från "feature" -grenen. I grund och botten har följande åtgärder ägt rum:

A - B - C - G (master) \ / E - F (funktion)

I Commit G har alla ändringar från "funktionsgren" införts till huvudgrenen. Men själva "funktionsgrenen" har förblivit orörd på grund av sammanslagningsprocessen. Lägg märke till hash för varje engagemang. Efter sammanslagningen har E (7c5c85e) och F (0286690) commit samma hash på 'feature' och 'master' gren.

3. Sammanfogar med rebasing

Låt oss upprepa steg 1 för att skapa filialerna "master" och "feature" igen.

Resultat för 'master':

$ git checkout master Byt till gren 'master' $ git log --oneline 7f573d8 Åtagande C: lagt till c.txt 795da3c Åtagande B: tillagd b.txt 0f4ed5b Åtgärd A: lagt till a.txt $ ls a.txt b.txt c.Text

Resultat för 'feature':

$ git checkout-funktion Bytt till filialfunktion $ git-logg --oneline 8ed0c4e Åtagande F: modifierad b.txt 6e12b57 Commit E: modifierad a.txt 795da3c Åtagande B: tillagd b.txt 0f4ed5b Åtagande A: lagt till a.txt $ ls a.txt b.Text

Låt oss starta om från 'funktionsgrenen'.

$ git checkout-funktion Bytt till filialfunktion $ git rebase master Först, spola tillbaka huvudet för att spela upp ditt arbete ovanpå det ... Tillämpar: Commit E: modifierat en.txt Tillämpar: Begå F: modifierad b.Text

Slå sedan samman 'funktion' till 'master'.

$ git checkout master Bytt till filial "master" $ git merge-funktion Uppdaterar 7f573d8 ... 9efa1a3 Snabbspolning framåt.txt | 1 + b.txt | 1 + 2 filer har ändrats, 2 infogningar (+)

Resultat för 'master' branch:

$ git checkout master Redan på "master" $ git log --oneline 9efa1a3 Åtgärd F: modifierad b.txt 8710174 Engagera E: modifierad a.txt 7f573d8 Åtgärd C: lagt till c.txt 795da3c Åtagande B: tillagd b.txt 0f4ed5b Åtagande A: lagt till a.txt $ ls a.txt b.txt c.Text

Resultat för 'feature' gren:

$ git checkout-funktion Bytt till filialfunktion $ git-logg --online 9efa1a3 Åtagande F: modifierad b.txt 8710174 Engagera E: modifierad a.txt 7f573d8 Åtgärd C: lagt till c.txt 795da3c Åtagande B: tillagd b.txt 0f4ed5b Åtagande A: lagt till a.txt $ ls a.txt b.txt c.Text

Lägg märke till att båda grenarna är desamma efter omstart och sammanslagning. Dessutom har hash för E och F förändrats i båda grenarna. I grund och botten, i rebasescenariot, så här:

A - B - C \ E '- F' (funktion, master)

Det är därför det inte finns något nytt åtagande. E- och F-åtagandena har räknats om och spärrats till slutet av "master" -grenen.

Omfasning är ett användbart verktyg när du vill städa upp historien om ditt arbete. Det finns dock en fara som har fött den gyllene regeln.

Gyllene regeln för rebasing

Den gyllene regeln för omgradering är:

Omför aldrig en offentlig filial.

Som du kan se från exemplet ovan, beräknar omförbindelserna omfördelning. När flera personer förgrenar sig från ett offentligt arkiv kan omstegning skapa situationer där utvecklare som har skapat nya filialer kommer att stöta på mycket komplicerade sammanfogningssituationer. Så det är en bra idé att aldrig ta bort offentliga filialer som delas.

Sammanfattningsvis:

Rebasing är en unik egenskap hos Git. Men använd den med försiktighet.

Mer information:

Här är några länkar för vidare studier:

Git Rebase-dokumentation
Atlassian Merging vs Rebasing

Referenser:

Spel Hur man installerar och spelar Doom på Linux
Hur man installerar och spelar Doom på Linux
Introduktion till Doom Doom-serien har sitt ursprung på 90-talet efter att den ursprungliga Doom släpptes. Det blev en omedelbar hit och från den tide...
Spel Vulkan för Linux-användare
Vulkan för Linux-användare
Med varje ny generation grafikkort ser vi spelutvecklare driva gränserna för grafisk trohet och komma ett steg närmare fotorealism. Men trots all kred...
Spel OpenTTD vs Simutrans
OpenTTD vs Simutrans
Att skapa din egen transportsimulering kan vara rolig, avkopplande och extremt lockande. Det är därför du måste se till att du testar så många spel so...