git rebase is een samenvoeghulpprogramma net als git merge. Maar de manier waarop ze werken is anders.

In dit artikel zal ik het hebben over hoe Git rebase werkt, de verschillen tussen Git rebase en Git merge, en hoe te werken met Git rebase. Dus laten we beginnen.

Git-rebase:

Laten we zeggen dat je een Git-repository hebt met de commits EEN, B, C in de meester Afdeling. Vervolgens heb je een nieuwe branch gemaakt een tak en 2 nieuwe commits toegevoegd D en E naar de een tak Afdeling.

Fig 1: initiële commit-geschiedenis.

Nu, laten we zeggen, je bent vergeten iets toe te voegen in de meester Afdeling. Dus je gaat terug naar de meester branch en voeg een nieuwe commit toe G naar de meester Afdeling. Je git-geschiedenis zou er als volgt uit moeten zien:.

Fig 2: commit geschiedenis na het toevoegen van commit G in de master branch.

Alles ziet er goed uit. Als u nu alle wijzigingen wilt die u hebt aangebracht in de een tak filiaal om in de . te zijn meester branch, kunt u de . samenvoegen een tak aftakking naar de meester Afdeling. Dit is wat git samenvoegen Doen.

Wat als je de commit wilt? G beschikbaar zijn in de een tak Afdeling? Nou, daar kun je git rebase voor gebruiken.

Uit de commit-geschiedenis in fig 2 kun je zien dat de branch een tak begint bij de commit C. Als je een git-rebase doet op een tak, dan zou het beginnen bij de commit G zoals weergegeven in figuur 3 hieronder:. Merk op dat de inhoud van de commit D en E zal ook veranderen na de rebase-bewerking. de verplichtingen D en E zal de wijzigingen in commit bevatten G. Daarom heb ik toegevoegd * symbool voor de commits D en E.

Als je wilt weten hoe de commit-geschiedenis eruit zou zien als ik het zou samenvoegen, kijk dan eens naar fig 4. Ik heb het toegevoegd zodat je het kunt vergelijken met git rebase.

Fig 4: commit geschiedenis als git merge werd gebruikt.

Nu je weet wat git rebase is, het verschil tussen git rebase en git merge en waarom git rebase het gebruikte, zal ik je laten zien hoe je het kunt gebruiken in de volgende sectie van dit artikel hieronder.

Git Rebase-workflow:

In deze sectie zal ik een nieuwe git-repository maken op mijn lokale computer en je laten zien hoe git rebase werkt. Ik raad je aan een goed begrip te hebben van git rebase voordat je het op je project toepast.

Maak eerst een nieuwe Git-repository rebase-demo/ op uw computer als volgt:

$ git init rebase-demo

Navigeer nu naar de rebase-demo/ map als volgt:

$ cd rebase-demo/

Maak nu een nieuw bestand aan test.tekst als volgt:

$ echo "A" > test.tekst

De test.txt-bestand bevat slechts één regel EEN. Laten we zeggen dat dit je eerste projectcode is.

Leg de wijzigingen nu als volgt vast:

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

Voeg nu nog een regel toe B naar de test.tekst bestand zoals weergegeven in de onderstaande schermafbeelding.

Leg de wijzigingen nu als volgt vast:

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

Laten we nu nog een regel C toevoegen aan de test.tekst het dossier.

Voer de wijzigingen ook als volgt door:

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

Nu zou de commit-geschiedenis van de master-branch er als volgt uit moeten zien:

$ git log --oneline

Laten we zeggen dat je een aantal nieuwe ideeën hebt die je wilt uitproberen. Dus laten we een nieuw filiaal maken en afrekenen nieuwe functie als volgt:

$ git checkout -b nieuwe-functie

Voeg nu uw nieuwe idee toe (de regel D laten we zeggen) naar de test.tekst het dossier.

Leg de wijzigingen nu als volgt vast:

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

Voeg nu de regel E toe aan de test.tekst het dossier.

Voer de wijzigingen als volgt door:

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

Nu, de commit-geschiedenis van de nieuwe functie tak moet er als volgt uitzien:

$ git log --oneline

Zie hoe de commits op volgorde staan ​​A < B < C < D < E?

Nu herinner je je dat je bent vergeten iets toe te voegen aan de meester filiaal waar je ook in de . had willen zijn nieuwe functie Afdeling! Dus, afrekenen naar de meester Afdeling.

Ik heb een nieuwe regel toegevoegd aan het einde van de test.tekst bestand zoals je kunt zien.

Leg de wijzigingen nu als volgt vast:

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

Nu, de commit-geschiedenis van de meester tak zou er zo uit moeten zien.

EEN < B < C < G

Nu, om de commits te rebasen van de meester aftakking naar de nieuwe functie filiaal, eerste kassa naar de nieuwe functie Afdeling.

$ git kassa nieuwe functie

Doe nu een git-rebase van de meester tak als volgt:

$ git rebase master

Sommige samenvoegconflicten! Laten we dat oplossen.

Nou, de wijzigingen die ik heb aangebracht in de commit G en D zijn in conflict met elkaar. Ik wil deze allebei houden.

Na het oplossen van het samenvoegconflict, test.tekst bestand zou er als volgt uit moeten zien:

Voeg nu de wijzigingen als volgt toe aan het staging-gebied:

$ git toevoegen .

Ga nu verder met de rebase en werk als volgt:

$ git rebase --continue

Nog een samenvoegconflict! Nou, dit kan gebeuren. Rebase verandert de git commit-geschiedenis. Dus dit soort dingen worden verwacht.

Het lijkt erop dat het samenvoegproces is mislukt vanwege enkele lege regels. Laten we dat oplossen.

Na het oplossen van het samenvoegconflict, test.tekst bestand zou er als volgt uit moeten zien.

Voeg nu de wijzigingen als volgt toe aan het staging-gebied:

$ git toevoegen .

Ga nu als volgt verder met de rebase-bewerking:

$ git rebase --continue

Git-rebase is voltooid.

Zoals je kunt zien, is de commit-geschiedenis van de branch met nieuwe functies bijgewerkt. Nu is de commit-geschiedenis als volgt:

EEN < B < C < G < D < E

Net zoals verwacht.

De laatste test.tekst bestand zou er als volgt uit moeten zien.

Git rebase is een krachtig hulpmiddel. Maar je moet het nooit gebruiken op gedeelde Git-repositories. Gebruik het alleen op de Git-repository's die u alleen gebruikt. Anders zul je onderweg veel problemen tegenkomen.

Dus zo gebruik je git rebase. Bedankt voor het lezen van dit artikel.