Rebasing är en process för att återansöka commits ovanpå en annan basresa. Den används för att tillämpa en sekvens av commits från distinkta grenar till en slutlig commit. Det är ett alternativ till git merge-kommandot. Det är en linjär process av sammanslagning.

I Git hänvisas till termen rebase som processen att flytta eller kombinera en sekvens av commits till en ny bas commit. Rebasing är mycket fördelaktigt och det visualiserade processen i miljön för ett funktionsförgrenande arbetsflöde.

Det är bra att bygga om din gren innan du slår ihop den.

I allmänhet är det ett alternativ till git merge-kommandot. Merge är alltid ett rekord som förändras framåt. Jämförelsevis är rebase ett övertygande historikomskrivningsverktyg i git. Det slår samman de olika commits en efter en.

Anta att du har gjort tre commits i din master-gren och tre i din andra gren med namnet test. Om du slår samman detta kommer det att slå samman alla commits på en gång. Men om du baserar om det, kommer det att slås samman på ett linjärt sätt. Tänk på bilden nedan:

Bilden ovan beskriver hur git rebase fungerar. Mastergrenens tre commits slås samman linjärt med commits för testgrenen.

Sammanslagning är det enklaste sättet att integrera grenarna. Den utför en trevägs sammanslagning mellan de två senaste grenbesluten.

Hur man rebaserar

När du gjorde några commits på en funktionsgren (testgren) och några i mastergrenen. Du kan basera om vilken som helst av dessa grenar. Använd kommandot git log för att spåra ändringarna (commit history). Checka ut till den önskade grenen du vill lägga om. Utför nu rebase-kommandot enligt följande:

Syntax:

 $git rebase 

Om det finns några konflikter i grenen, lös dem och utför nedanstående kommandon för att fortsätta ändringarna:

 $ git status 

Den används för att kontrollera status,

 $git rebase --continue 

Kommandot ovan används för att fortsätta med de ändringar du gjort. Om du vill hoppa över ändringen kan du hoppa över enligt följande:

statisk java

 $ git rebase --skip 

När rebaseringen är klar. Skjut förvaret till ursprunget. Betrakta exemplet nedan för att förstå kommandot git merge.

Anta att du har en gren säg test 2 som du arbetar med. Du är nu på test2-grenen och gjorde några ändringar i projektets fil nyfil1.txt .

Lägg till denna fil i arkivet:

 $ git add newfile1.txt 

Gör nu ändringarna. Använd kommandot nedan:

 $ git commit -m 'new commit for test2 branch.' 

Utgången kommer att se ut så här:

 [test2 a835504] new commitfor test2 branch 1 file changed, 1 insertion(+) 

Växla grenen till master:

 $ git checkout master 

Produktion:

 Switched to branch 'master.' Your branch is up to date with 'origin/master.' 

Nu är du på mastergrenen. Jag har lagt till ändringarna i min fil, säger nyfil.txt . Kommandot nedan används för att lägga till filen i förvaret.

 $ git add newfile.txt 

Bekräfta nu filen för ändringar:

 $ git commit -m ' new commit made on the master branch.' 

Produktion:

 [master 7fe5e7a] new commit made on master 1 file changed, 1 insertion(+) HiMaNshU@HiMaNshU-PC MINGW64 ~/Desktop/GitExample2 (master) 

För att kontrollera logghistoriken, utför kommandot nedan.

 $ git log --oneline 

Produktion:

Som vi kan se i logghistoriken finns det en ny commit i mastergrenen. Om jag vill bygga om min test2-gren, vad ska jag göra? Se nedanstående rebase branch scenario:

Rebase-gren

Om vi ​​har många commits från olika grenar och vill slå ihop det i en. För att göra det har vi två val, antingen kan vi slå ihop det eller lägga om det. Det är bra att lägga om sin gren.

Från exemplet ovan har vi förbundit oss till mastergrenen och vill basera om den på test2-grenen. Låt oss se kommandona nedan:

 $ git checkout test2 

Detta kommando sätter dig på test2-grenen från mastern.

Produktion:

 Switched to branch 'test2.' 

Nu är du på test2-grenen. Därför kan du basera om test2-grenen med master-grenen. Se kommandot nedan:

 $ git rebase master 

Detta kommando kommer att basera om test2-grenen och visas som Ansöker: ny commit på test2-gren . Tänk på följande utdata:

java arv

Produktion:

Git Interactive Rebase

Git underlättar med Interactive Rebase; det är ett kraftfullt verktyg som tillåter olika operationer som redigera, skriva om, ordna om, och mer om befintliga åtaganden. Interactive Rebase kan endast användas på den utcheckade grenen. Ställ därför in din lokala HEAD-gren i sidofältet.

shehzad poonawala

Git interaktiv rebase kan anropas med rebase-kommando, bara skriv -jag tillsammans med rebase-kommandot. här' i ' står för interaktiv. Syntaxen för detta kommando ges nedan:

Syntax:

 $ git rebase -i 

Det kommer att lista alla tillgängliga interaktiva alternativ.

Produktion:

Efter den givna utgången öppnas en redigerare med tillgängliga alternativ. Tänk på följande utdata:

Produktion:

När vi utför git interaktiva rebase-kommandot kommer det att öppna din standardtextredigerare med ovanstående utdata.

Alternativen den innehåller listas nedan:

• Plocka
• Omformulera
• Redigera
• Squash
• Fixa till
• Exec
• Ha sönder
• Släppa
• Märka
• Återställa
• Sammanfoga

Ovanstående alternativ utför sina specifika uppgifter med git-rebase. Låt oss förstå vart och ett av dessa alternativ i korthet.

Välj (-p):

Pick står här att commit ingår. Ordningen på commits beror på ordningen på plockkommandona under rebase. Om du inte vill lägga till en commit måste du ta bort hela raden.

Omformulera (-r):

Omordet är ganska likt pick-kommandot. Omformuleringsalternativet pausade rebase-processen och ger en chans att ändra commit-meddelandet. Det påverkar inte några ändringar som görs av åtagandet.

Edit(er):

Redigeringsalternativet gör det möjligt att ändra commit. Ändringsmedlen, åtaganden kan läggas till eller ändras helt. Vi kan också göra ytterligare commits innan rebase continue-kommandot. Det tillåter oss att dela upp en stor commit i den mindre commit; Dessutom kan vi ta bort felaktiga ändringar som gjorts i en commit.

Squash (-s):

Squash-alternativet låter dig kombinera två eller flera commits till en enda commit. Det låter oss också skriva ett nytt commit-meddelande för att beskriva ändringarna.

Fixup (-f):

Det är ganska likt kommandot squash. Det förkastade budskapet om åtagandet att slås samman. Det äldre commit-meddelandet används för att beskriva båda ändringarna.

Exec (-x):

Exec-alternativet låter dig köra godtyckliga skalkommandon mot en commit.

Paus (-b):

Brytalternativet stoppar rebasing vid just position. Det kommer att fortsätta rebasera senare med ' git rebase --fortsätt ' kommando.

Släpp (-d):

Drop-alternativet används för att ta bort commit.

Etikett (-l):

Etikettalternativet används för att markera den aktuella huvudpositionen med ett namn.

Återställ (-t):

Återställningsalternativet används för att återställa huvudet till en etikett.

do and while loop i java

GitMerge vs. Rebase

Det är en vanligast förbryllande fråga för git-användare att när man ska använda merge-kommandot och när man ska använda rebase. Båda kommandona liknar varandra, och båda används för att slå samman commits som gjorts av de olika grenarna av ett arkiv.

Ombasering rekommenderas inte i en delad gren eftersom ombaseringsprocessen kommer att skapa inkonsekventa arkiv. För individer kan rebasing vara mer användbart än att slå samman. Om du vill se hela historiken bör du använda sammanslagningen. Merge spårar hela historiken för åtaganden, medan rebase skriver om en ny.

Git rebase-kommandon sägs som ett alternativ till git merge. Men de har några viktiga skillnader: