Rebasen is een proces waarbij commits opnieuw worden toegepast bovenop een andere basisreis. Het wordt gebruikt om een ​​reeks commits van verschillende takken toe te passen in een definitieve commit. Het is een alternatief voor het git merge-commando. Het is een lineair proces van samensmelten.

In Git wordt de term rebase aangeduid als het proces van het verplaatsen of combineren van een reeks commits naar een nieuwe basiscommit. Rebasen is zeer nuttig en visualiseert het proces in de omgeving van een workflow voor het vertakken van functies.

Het is goed om uw branch opnieuw te baseren voordat u deze samenvoegt.

Over het algemeen is het een alternatief voor het git merge commando. Samenvoegen is altijd een voorwaarts veranderend record. Ter vergelijking: rebase is een overtuigend hulpmiddel voor het herschrijven van de geschiedenis in git. Het voegt de verschillende commits één voor één samen.

Stel dat je drie commits hebt gemaakt in je master branch en drie in je andere branch genaamd test. Als je dit samenvoegt, worden alle commits in één keer samengevoegd. Maar als u het opnieuw baseert, wordt het op een lineaire manier samengevoegd. Beschouw de onderstaande afbeelding:

De bovenstaande afbeelding beschrijft hoe git rebase werkt. De drie commits van de master branch worden lineair samengevoegd met de commits van de test branch.

Samenvoegen is de meest eenvoudige manier om de vestigingen te integreren. Het voert een samenvoeging in drie richtingen uit tussen de twee laatste branch commits.

Hoe te rebasen

Wanneer je een aantal commits hebt gemaakt op een feature branch (test branch) en een aantal in de master branch. Je kunt elk van deze branches rebasen. Gebruik het git log commando om de wijzigingen bij te houden (commitgeschiedenis). Afrekenen bij het gewenste filiaal dat u wilt rebasen. Voer nu het rebase-commando als volgt uit:

Syntaxis:

 $git rebase 

Als er conflicten zijn in de vertakking, los deze dan op en voer onderstaande opdrachten uit om door te gaan met de wijzigingen:

 $ git status 

Het wordt gebruikt om de status te controleren,

 $git rebase --continue 

De bovenstaande opdracht wordt gebruikt om door te gaan met de wijzigingen die u hebt aangebracht. Als u de wijziging wilt overslaan, kunt u dit als volgt overslaan:

mergesort-algoritme

 $ git rebase --skip 

Wanneer het opnieuw baseren is voltooid. Duw de repository naar de oorsprong. Bekijk het onderstaande voorbeeld om het git merge commando te begrijpen.

Stel dat je een filiaal zegt proef2 waaraan u werkt. U bevindt zich nu op de test2-branch en heeft enkele wijzigingen aangebracht in het projectbestand nieuwbestand1.txt .

Voeg dit bestand toe aan de repository:

 $ git add newfile1.txt 

Leg nu de wijzigingen vast. Gebruik het onderstaande commando:

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

De uitvoer ziet er als volgt uit:

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

Schakel de tak naar master:

 $ git checkout master 

Uitgang:

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

Nu bevindt u zich in de masterbranch. Ik heb de wijzigingen aan mijn bestand toegevoegd, zegt nieuwbestand.txt . De onderstaande opdracht wordt gebruikt om het bestand aan de repository toe te voegen.

 $ git add newfile.txt 

Leg nu het bestand vast voor wijzigingen:

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

Uitgang:

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

Voer de onderstaande opdracht uit om de loggeschiedenis te controleren.

 $ git log --oneline 

Uitgang:

Zoals we in de loggeschiedenis kunnen zien, is er een nieuwe commit in de master branch. Wat moet ik doen als ik mijn test2 branch wil rebasen? Zie het onderstaande rebase branch-scenario:

Rebase-filiaal

Als we veel commits van verschillende branches hebben en deze in één willen samenvoegen. Om dit te doen, hebben we twee keuzes: we kunnen het samenvoegen of opnieuw baseren. Het is goed om uw branch te rebasen.

Uit het bovenstaande voorbeeld hebben we ons gecommitteerd aan de master branch en willen deze opnieuw baseren op de test2 branch. Laten we de onderstaande opdrachten bekijken:

afrekenen in git

 $ git checkout test2 

Met dit commando wordt u vanaf de master naar de test2-vertakking overgeschakeld.

Uitgang:

 Switched to branch 'test2.' 

Nu bevindt u zich op de test2-tak. Daarom kunt u de test2-branch rebasen met de master-branch. Zie het onderstaande commando:

 $ git rebase master 

Met dit commando wordt de tak test2 opnieuw gebaseerd en wordt weergegeven als Toepassen: nieuwe commit op test2 branch . Beschouw de onderstaande uitvoer:

Uitgang:

Git Interactieve Rebase

Git faciliteert met Interactive Rebase; het is een krachtig hulpmiddel dat verschillende bewerkingen mogelijk maakt, zoals bewerken, herschrijven, opnieuw ordenen, en meer over bestaande commits. Interactive Rebase kan alleen worden gebruikt in het momenteel uitgecheckte filiaal. Zet daarom uw lokale HEAD-filiaal in de zijbalk.

Git interactieve rebase kan worden aangeroepen met het rebase-commando, typ gewoon -i samen met het rebase-commando. Hier ' i ' staat voor interactief. De syntaxis van deze opdracht wordt hieronder gegeven:

Syntaxis:

 $ git rebase -i 

Het toont alle beschikbare interactieve opties.

Uitgang:

Na de gegeven uitvoer wordt een editor geopend met beschikbare opties. Beschouw de onderstaande uitvoer:

Uitgang:

Wanneer we het git interactieve rebase commando uitvoeren, zal het je standaard teksteditor openen met de bovenstaande uitvoer.

De opties die het bevat, worden hieronder vermeld:

• Kies
• Herformuleren
• Bewerking
• Squash
• Opknappen
• Exec
• Pauze
• Druppel
• Etiket
• Opnieuw instellen
• Samenvoegen

De bovenstaande opties voeren hun specifieke taken uit met git-rebase. Laten we elk van deze opties in het kort begrijpen.

Kies (-p):

Pick staat hier dat de commit is inbegrepen. De volgorde van de commits hangt af van de volgorde van de pick-opdrachten tijdens rebase. Als je geen commit wilt toevoegen, moet je de hele regel verwijderen.

Herformuleren (-r):

vang en probeer Java

De herformulering lijkt veel op het kiescommando. De reword-optie pauzeerde het rebase-proces en biedt een kans om het commit-bericht te wijzigen. Het heeft geen invloed op eventuele wijzigingen die door de commit zijn aangebracht.

Bewerken:

Met de bewerkingsoptie kunt u de commit wijzigen. De wijziging betekent dat commits geheel kunnen worden toegevoegd of gewijzigd. We kunnen ook extra commits doen voordat we de opdracht rebase continueren. Het stelt ons in staat een grote commit op te splitsen in een kleinere commit; bovendien kunnen we foutieve wijzigingen die in een commit zijn aangebracht, verwijderen.

Pompoen (-s):

Met de squashoptie kun je twee of meer commits combineren in één enkele commit. Het stelt ons ook in staat een nieuw commit-bericht te schrijven waarin de wijzigingen worden beschreven.

Oplossen (-f):

Het lijkt veel op het squash-commando. Het bericht van de commit die moet worden samengevoegd, wordt verwijderd. Het oudere commit-bericht wordt gebruikt om beide wijzigingen te beschrijven.

Uitvoeren (-x):

Met de exec-optie kunt u willekeurige shell-opdrachten uitvoeren tegen een commit.

Pauze (-b):

De break-optie stopt het rebasen op slechts één positie. Het zal later doorgaan met rebasen met ' git rebase --ga verder ' commando.

Daling (-d):

De drop-optie wordt gebruikt om de commit te verwijderen.

Etiket (-l):

De labeloptie wordt gebruikt om de huidige hoofdpositie met een naam te markeren.

Opnieuw instellen (-t):

De reset-optie wordt gebruikt om de kop naar een label te resetten.

ankita dave

GitMerge versus rebase

Het is een meest voorkomende raadselachtige vraag voor git-gebruikers: wanneer moet je het merge-commando gebruiken en wanneer moet je rebase gebruiken. Beide commando's zijn vergelijkbaar, en beide worden gebruikt om de commits van de verschillende takken van een repository samen te voegen.

Het opnieuw baseren wordt niet aanbevolen in een gedeelde vertakking, omdat het proces van het opnieuw baseren inconsistente opslagplaatsen zal creëren. Voor individuen kan rebasen nuttiger zijn dan samenvoegen. Als je de volledige geschiedenis wilt zien, moet je de samenvoeging gebruiken. Merge houdt de hele geschiedenis van commits bij, terwijl rebase een nieuwe herschrijft.

Git rebase-opdrachten zeiden als alternatief voor git merge. Ze hebben echter enkele belangrijke verschillen: