Rebasering er en proces til at genanvende commits oven på en anden basisrejse. Det bruges til at anvende en sekvens af commits fra forskellige grene til en endelig commit. Det er et alternativ til git merge-kommandoen. Det er en lineær fusionsproces.

I Git omtales udtrykket rebase som processen med at flytte eller kombinere en sekvens af commits til en ny base commit. Rebasing er meget fordelagtigt, og det visualiserede processen i miljøet af en funktionsforgrenende arbejdsgang.

Det er godt at rebase din gren, før du slår den sammen.

Generelt er det et alternativ til git merge-kommandoen. Merge er altid en rekord, der skifter fremad. Til sammenligning er rebase et overbevisende historieomskrivningsværktøj i git. Det smelter de forskellige commits sammen én efter én.

Antag, at du har lavet tre commits i din master-gren og tre i din anden gren-navngivne test. Hvis du fusionerer dette, vil det fusionere alle commits på en gang. Men hvis du rebaserer det, vil det blive flettet på en lineær måde. Overvej billedet nedenfor:

Ovenstående billede beskriver, hvordan git rebase fungerer. De tre commits af mastergrenen er flettet lineært sammen med commits af testgrenen.

Sammenlægning er den mest ligetil måde at integrere grenene på. Det udfører en tre-vejs fusion mellem de to seneste brancheforpligtelser.

Sådan genbaseres

Når du foretog nogle commits på en feature-gren (testgren) og nogle i master-grenen. Du kan rebase enhver af disse grene. Brug git log kommandoen til at spore ændringerne (commit history). Check ud til den ønskede filial, du vil ombase. Udfør nu rebase-kommandoen som følger:

Syntaks:

 $git rebase 

Hvis der er nogle konflikter i grenen, skal du løse dem og udføre nedenstående kommandoer for at fortsætte ændringer:

 $ git status 

Det bruges til at kontrollere status,

 $git rebase --continue 

Ovenstående kommando bruges til at fortsætte med de ændringer, du har foretaget. Hvis du vil springe ændringen over, kan du springe over som følger:

liste sortere java

 $ git rebase --skip 

Når rebaseringen er afsluttet. Skub lageret til oprindelsen. Overvej nedenstående eksempel for at forstå git merge-kommandoen.

Antag, at du har en gren siger test 2 som du arbejder på. Du er nu på test2-grenen og har lavet nogle ændringer i projektets fil nyfil1.txt .

Tilføj denne fil til repository:

 $ git add newfile1.txt 

Forpligt nu ændringerne. Brug nedenstående kommando:

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

Outputtet vil se sådan ud:

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

Skift grenen til master:

 $ git checkout master 

Produktion:

postordregennemgang

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

Nu er du på mestergrenen. Jeg har tilføjet ændringerne til min fil, siger nyfil.txt . Nedenstående kommando bruges til at tilføje filen i depotet.

 $ git add newfile.txt 

Bekræft nu filen til ændringer:

 $ 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) 

For at kontrollere loghistorikken skal du udføre kommandoen nedenfor.

 $ git log --oneline 

Produktion:

Som vi kan se i loghistorien, er der en ny commit i mastergrenen. Hvad skal jeg gøre, hvis jeg vil rebase min test2-gren? Se nedenstående rebase branch scenario:

Rebase-gren

Hvis vi har mange commits fra forskellige brancher og ønsker at slå det sammen i én. For at gøre det har vi to valg, enten vi kan flette det eller rebase det. Det er godt at rebase din gren.

Fra ovenstående eksempel har vi forpligtet os til mastergrenen og ønsker at rebasere den på test2-grenen. Lad os se nedenstående kommandoer:

 $ git checkout test2 

Denne kommando vil tænde for test2-grenen fra masteren.

Produktion:

 Switched to branch 'test2.' 

Nu er du på test2-grenen. Derfor kan du rebase test2-grenen med master-grenen. Se nedenstående kommando:

 $ git rebase master 

Denne kommando vil rebasere test2-grenen og vil vise som Ansøger: ny commit på test2 branch . Overvej nedenstående output:

Produktion:

Git Interactive Rebase

Git letter med Interactive Rebase; det er et potent værktøj, der tillader forskellige operationer som f.eks redigere, omskrive, omarrangere, og mere om eksisterende tilsagn. Interactive Rebase kan kun betjenes på den aktuelt tjekkede filial. Indstil derfor din lokale HEAD-afdeling i sidebjælken.

Git interaktiv rebase kan påkaldes med rebase kommando, bare skriv -jeg sammen med rebase-kommando. Her ' jeg ' står for interaktiv. Syntaks for denne kommando er angivet nedenfor:

Syntaks:

 $ git rebase -i 

Det vil vise alle de tilgængelige interaktive muligheder.

Produktion:

bfs og dfs

Efter det givne output vil det åbne en editor med tilgængelige muligheder. Overvej nedenstående output:

Produktion:

Når vi udfører git interaktiv rebase-kommandoen, åbner den din standard teksteditor med ovenstående output.

De muligheder, den indeholder, er anført nedenfor:

• Plukke
• Omformulere
• Redigere
• Squash
• Ordne
• Exec
• Pause
• Dråbe
• Etiket
• Nulstil
• Fusionere

Ovenstående muligheder udfører deres specifikke opgaver med git-rebase. Lad os kort forstå hver af disse muligheder.

Vælg (-p):

Pick står her, at commit er inkluderet. Rækkefølgen af ​​commits afhænger af rækkefølgen af ​​pick-kommandoerne under rebase. Hvis du ikke vil tilføje en commit, skal du slette hele linjen.

Omord (-r):

Omordet minder ret meget om pick-kommando. Omformuleringsindstillingen satte rebase-processen på pause og giver mulighed for at ændre commit-meddelelsen. Det påvirker ikke eventuelle ændringer foretaget af commit.

Redigering(er):

Redigeringsmuligheden giver mulighed for at ændre commit. Ændringsmidlerne, tilsagn kan tilføjes eller ændres helt. Vi kan også foretage yderligere commits før rebase fortsæt kommando. Det giver os mulighed for at dele en stor commit op i den mindre commit; desuden kan vi fjerne fejlagtige ændringer foretaget i en commit.

Squash (-s):

Squash-indstillingen giver dig mulighed for at kombinere to eller flere commits til en enkelt commit. Det giver os også mulighed for at skrive en ny commit-besked til beskrivelse af ændringerne.

Fixup (-f):

Det ligner meget squash-kommandoen. Det kasserede budskabet om forpligtelsen til at blive fusioneret. Den ældre commit-meddelelse bruges til at beskrive begge ændringer.

Exec (-x):

Exec-indstillingen giver dig mulighed for at køre vilkårlige shell-kommandoer mod en commit.

Pause (-b):

Pause-muligheden stopper rebasing ved lige position. Det vil fortsætte med at rebasere senere med ' git rebase --fortsæt ' kommando.

Drop (-d):

Drop-indstillingen bruges til at fjerne commit.

Etiket (-l):

Etiketmuligheden bruges til at markere den aktuelle hovedposition med et navn.

Nulstil (-t):

Nulstillingsmuligheden bruges til at nulstille hovedet til en etiket.

while og do while loop i java

GitMerge vs. Rebase

Det er et mest almindeligt gådefuldt spørgsmål for git-brugeren, hvornår man skal bruge merge-kommandoen, og hvornår man skal bruge rebase. Begge kommandoer ligner hinanden, og begge bruges til at flette de tilsagn, der er foretaget af de forskellige grene af et lager.

Genbasering anbefales ikke i en delt gren, fordi rebaseringsprocessen vil skabe inkonsistente lagre. For enkeltpersoner kan rebasering være mere nyttig end sammenlægning. Hvis du vil se hele historikken, skal du bruge fletningen. Merge sporer hele historien om commits, mens rebase omskriver en ny.

Git rebase kommandoer sagt som et alternativ til git merge. De har dog nogle vigtige forskelle: