git rebase är ett sammanslagningsverktyg precis som git merge. Men sättet de arbetar på är annorlunda.

I den här artikeln kommer jag att prata om hur Git rebase fungerar, skillnaderna mellan Git rebase och Git sammanfogar, och hur man arbetar med Git rebase. Så, låt oss komma igång.

Git Rebase:

Låt oss säga att du har ett Git-arkiv med åtagandena A, B, C i bemästra gren. Sedan skapade du en ny gren någon gren och lade till två nya åtaganden D och E till någon gren gren.

Fig 1: ursprunglig åtagandeshistorik.

Låt oss säga att du glömde att lägga till något i bemästra gren. Så, du går tillbaka till bemästra filial och lägg till ett nytt engagemang G till bemästra gren. Din git-historik ska se ut enligt följande.

Figur 2: begå historik efter att ha lagt till G i huvudgrenen.

Allt ser bra ut. Nu, om du ville ha alla ändringar du har gjort i någon gren gren att vara i bemästra filial, kan du slå samman någon gren gren till bemästra gren. Det här är vad git sammanfoga do.

Vad händer om du vill göra det G att vara tillgänglig i någon gren gren? Du kan använda git rebase för det.

Från engagemangshistoriken i fig 2 kan du se att filialen någon gren börjar från åtagandet C. Om du gör en git rebase på någon gren, då skulle det börja från åtagandet G som visas i fig 3 nedan. Observera att innehållet i åtagandet D och E kommer också att ändras efter rebase-operationen. Det åtar sig D och E kommer att inkludera ändringarna i åtagandet G. Det är därför jag tillade * symbolen innan du gör det D och E.

Om du vill veta hur engagemangshistoriken skulle se ut om jag slog samman den, ta en titt på fig 4. Jag har inkluderat det bara så att du kan jämföra det med git rebase.

Fig 4: begå historik om git-merge användes.

Nu när du vet vad som är git rebase, skillnaden mellan git rebase och git merge och varför git rebase den använde, kommer jag att visa dig hur du använder den i nästa avsnitt i den här artikeln nedan.

Git Rebase Workflow:

I det här avsnittet skapar jag ett nytt git-arkiv på min lokala dator och visar hur git rebase fungerar. Jag rekommenderar att du förstår git rebase innan du använder den på ditt projekt.

Skapa först ett nytt Git-arkiv rebase-demo / på din dator enligt följande:

$ git init rebase-demo

Navigera nu till rebase-demo / katalog enligt följande:

$ cd rebase-demo /

Skapa nu en ny fil testa.Text som följer:

$ echo "A"> test.Text

Testet.txt-filen innehåller endast en rad A. Låt oss säga att detta är din ursprungliga projektkod.

Nu gör du ändringarna enligt följande:

$ git add .
$ git commit -m 'A'

Lägg nu till en rad till B till testa.Text fil som visas på skärmdumpen nedan.

Nu gör du ändringarna enligt följande:

$ git add .
$ git commit -m 'B'

Låt oss nu lägga till ytterligare en rad C i testa.Text fil.

Gör också ändringarna enligt följande:

$ git add .
$ git commit -m 'C'

Nu ska mastergrenens engagemangshistorik se ut så här:

$ git log - online

Låt oss säga att du har några nya idéer som du vill prova. Så, låt oss skapa och checka ut till en ny gren ny funktion som följer:

$ git checkout -b ny funktion

Lägg nu till din nya idé (raden D låt oss säga) till testa.Text fil.

Nu gör du ändringarna enligt följande:

$ git add .
$ git commit -m 'D'

Lägg nu till raden E till testa.Text fil.

Genomför ändringarna enligt följande:

$ git add .
$ git commit -m 'E'

Nu, begå historia av ny funktion filial ska se ut som följer:

$ git log - online

Se hur åtagandena är i ordning A < B < C < D < E?

Nu kommer du ihåg att du glömde att lägga till något i bemästra gren som du också ville vara i ny funktion gren! Så, kassan till bemästra gren.

Jag lade till en ny rad i slutet av testa.Text fil som du kan se.

Nu gör du ändringarna enligt följande:

$ git add .
$ git commit -m 'G'

Nu, begå historia av bemästra gren ska se ut så här.

A < B < C < G

Nu, för att ompröva åtagandena från bemästra gren till ny funktion filial, första kassan till ny funktion gren.

$ git kassan ny funktion

Nu gör en git rebase av bemästra gren enligt följande:

$ git rebase master

Vissa sammanfogar konflikter! Låt oss fixa det.

Tja, de ändringar jag har gjort i åtagandet G och D är i konflikt med varandra. Jag vill behålla båda dessa.

Efter att ha löst sammanfogningskonflikten, testa.Text filen ska se ut som följer:

Lägg nu till ändringarna i iscensättningsområdet enligt följande:

$ git add .

Fortsätt nu rebasen som fungerar enligt följande:

$ git rebase - fortsätt

Ytterligare en sammanslagningskonflikt! Det kan hända. Rebase ändrar git commit-historiken. Så saker som detta förväntas.

Det verkar som om sammanslagningsprocessen misslyckades på grund av några tomma rader. Låt oss fixa det.

Efter att ha löst sammanfogningskonflikten, testa.Text filen ska se ut enligt följande.

Lägg nu till ändringarna i iscensättningsområdet enligt följande:

$ git add .

Fortsätt nu rebasoperationen enligt följande:

$ git rebase - fortsätt

Git rebase är klar.

Som du kan se uppdateras engagemangshistoriken för den nya funktionsgrenen. Nu är engagemangshistoriken som följer:

A < B < C < G < D < E

Precis som förväntat.

Den slutliga testa.Text filen ska se ut enligt följande.

Git rebase är ett kraftfullt verktyg. Men du ska aldrig använda den på delade Git-arkiv. Använd den bara på Git-arkiv som du bara arbetar. Annars kommer du att möta många problem på vägen.

Så det är så du använder git rebase. Tack för att du läste den här artikeln.