Rebasing er en prosess for å søke på nytt forpliktelser på toppen av en annen basereise. Den brukes til å bruke en sekvens av forpliktelser fra forskjellige grener til en endelig forpliktelse. Det er et alternativ til git merge-kommandoen. Det er en lineær prosess med sammenslåing.

I Git blir begrepet rebase referert til som prosessen med å flytte eller kombinere en sekvens av commits til en ny base commit. Rebasing er veldig fordelaktig, og det visualiserte prosessen i miljøet til en arbeidsflyt for funksjoner.

Det er greit å rebase grenen din før du slår den sammen.

Generelt er det et alternativ til git merge-kommandoen. Sammenslåing er alltid en rekord i endring. Til sammenligning er rebase et overbevisende verktøy for omskrivning av historie i git. Den slår sammen de forskjellige forpliktelsene én etter én.

Anta at du har gjort tre commits i mastergrenen din og tre i den andre grenen som heter test. Hvis du slår sammen dette, vil det slå sammen alle forpliktelser på en gang. Men hvis du baserer det på nytt, vil det bli slått sammen på en lineær måte. Tenk på bildet nedenfor:

Bildet ovenfor beskriver hvordan git rebase fungerer. De tre commitene til mastergrenen slås sammen lineært med commitene til testgrenen.

Sammenslåing er den enkleste måten å integrere grenene på. Den utfører en treveis sammenslåing mellom de to siste grenforpliktelsene.

Hvordan rebase

Når du gjorde noen forpliktelser på en funksjonsgren (testgren) og noen i hovedgrenen. Du kan rebase hvilken som helst av disse grenene. Bruk git log-kommandoen for å spore endringene (commit history). Sjekk ut til ønsket filial du ønsker å rebase. Utfør nå rebase-kommandoen som følger:

Syntaks:

 $git rebase 

Hvis det er noen konflikter i grenen, løs dem og utfør kommandoene nedenfor for å fortsette endringene:

 $ git status 

Den brukes til å sjekke status,

 $git rebase --continue 

Kommandoen ovenfor brukes til å fortsette med endringene du har gjort. Hvis du vil hoppe over endringen, kan du hoppe over som følger:

kvartal i virksomhet

 $ git rebase --skip 

Når rebaseringen er fullført. Skyv depotet til opprinnelsen. Tenk på eksemplet nedenfor for å forstå git merge-kommandoen.

Anta at du har en gren si test 2 som du jobber med. Du er nå på test2-grenen og har gjort noen endringer i prosjektets fil nyfil1.txt .

Legg til denne filen i depotet:

 $ git add newfile1.txt 

Nå, forplikte endringene. Bruk kommandoen nedenfor:

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

Utgangen vil se slik ut:

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

Bytt grenen til master:

 $ git checkout master 

Produksjon:

postordregjennomgang

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

Nå er du på mastergrenen. Jeg har lagt til endringene i filen min, sier nyfil.txt . Kommandoen nedenfor brukes til å legge til filen i depotet.

 $ git add newfile.txt 

Bevis nå filen for endringer:

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

Produksjon:

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

For å sjekke logghistorikken, utfør kommandoen nedenfor.

 $ git log --oneline 

Produksjon:

Som vi kan se i logghistorikken er det en ny commit i mastergrenen. Hvis jeg vil rebase test2-grenen min, hva bør jeg gjøre? Se rebase-gren-scenarioet nedenfor:

Rebase-gren

Hvis vi har mange forpliktelser fra forskjellige grener og ønsker å slå det sammen i en. For å gjøre det har vi to valg, enten vi kan slå det sammen eller basere det på nytt. Det er greit å rebase grenen din.

Fra eksemplet ovenfor har vi forpliktet oss til mastergrenen og ønsker å basere den på nytt på test2-grenen. La oss se kommandoene nedenfor:

 $ git checkout test2 

Denne kommandoen slår deg på test2-grenen fra masteren.

Produksjon:

 Switched to branch 'test2.' 

Nå er du på test2-grenen. Derfor kan du rebase test2-grenen med master-grenen. Se kommandoen nedenfor:

 $ git rebase master 

Denne kommandoen vil basere test2-grenen på nytt og vises som Søker: ny forpliktelse på test2-gren . Tenk på utgangen nedenfor:

Produksjon:

Git Interactive Rebase

Git forenkler med Interactive Rebase; det er et potent verktøy som tillater ulike operasjoner som redigere, omskrive, omorganisere, og mer om eksisterende forpliktelser. Interactive Rebase kan kun betjenes på den utsjekkede grenen. Sett derfor din lokale HEAD-avdeling i sidefeltet.

Git interaktiv rebase kan påkalles med rebase-kommando, bare skriv -Jeg sammen med rebase-kommando. her' Jeg ' står for interaktiv. Syntaks for denne kommandoen er gitt nedenfor:

Syntaks:

 $ git rebase -i 

Den vil vise alle tilgjengelige interaktive alternativer.

Produksjon:

string concat java

Etter den gitte utgangen vil den åpne en editor med tilgjengelige alternativer. Tenk på utgangen nedenfor:

Produksjon:

Når vi utfører git interaktiv rebase-kommandoen, vil den åpne standard tekstredigeringsprogram med utgangen ovenfor.

Alternativene den inneholder er oppført nedenfor:

• Plukke
• Omord
• Redigere
• Squash
• Reparasjon
• Exec
• Gå i stykker
• Miste
• Merkelapp
• Nullstille
• Slå sammen

Alternativene ovenfor utfører sine spesifikke oppgaver med git-rebase. La oss kort forstå hvert av disse alternativene.

Velg (-p):

Pick står her at commit er inkludert. Rekkefølgen på forpliktelsene avhenger av rekkefølgen på plukkekommandoene under rebase. Hvis du ikke vil legge til en commit, må du slette hele linjen.

Omord (-r):

Omordet er ganske likt pick-kommando. Omordalternativet stoppet rebase-prosessen og gir en sjanse til å endre commit-meldingen. Det påvirker ikke eventuelle endringer gjort av forpliktelsen.

Redigering(er):

Redigeringsalternativet gjør det mulig å endre forpliktelsen. Endringene betyr, forpliktelser kan legges til eller endres helt. Vi kan også foreta flere forpliktelser før rebase fortsett kommando. Det lar oss dele en stor forpliktelse inn i den mindre forpliktelsen; dessuten kan vi fjerne feilaktige endringer gjort i en commit.

Squash (-er):

Squash-alternativet lar deg kombinere to eller flere forpliktelser til en enkelt forpliktelse. Den lar oss også skrive en ny forpliktelsesmelding for å beskrive endringene.

Reparasjon (-f):

Det er ganske likt squash-kommandoen. Den forkastet meldingen om forpliktelsen som skal slås sammen. Den eldre commit-meldingen brukes til å beskrive begge endringene.

Utfør (-x):

Exec-alternativet lar deg kjøre vilkårlige shell-kommandoer mot en commit.

Pause (-b):

Pause-alternativet stopper rebasing ved just posisjon. Det vil fortsette å rebase senere med ' git rebase --fortsett ' kommando.

Slipp (-d):

Drop-alternativet brukes til å fjerne commit.

Etikett (-l):

Etikettalternativet brukes til å merke gjeldende hodeposisjon med et navn.

Tilbakestill (-t):

Tilbakestillingsalternativet brukes til å tilbakestille hodet til en etikett.

syreegenskaper i dbms

GitMerge vs. Rebase

Det er et vanligste forvirrende spørsmål for git-brukeren at når de skal bruke merge-kommandoen og når de skal bruke rebase. Begge kommandoene er like, og begge brukes til å slå sammen forpliktelsene som er gjort av de forskjellige grenene til et depot.

Rebasing anbefales ikke i en delt gren fordi rebasing-prosessen vil skape inkonsekvente repositories. For enkeltpersoner kan rebasing være mer nyttig enn å slå sammen. Hvis du vil se hele historien, bør du bruke sammenslåingen. Merge sporer hele historien til forpliktelser, mens rebase skriver om en ny.

Git rebase-kommandoer sagt som et alternativ til git merge. Imidlertid har de noen viktige forskjeller: