git rebase er et fusionsværktøj ligesom git fusion. Men den måde, de arbejder på, er anderledes.

I denne artikel vil jeg tale om, hvordan Git rebase fungerer, forskellene mellem Git rebase og Git fusionerer, og hvordan man arbejder med Git rebase. Så lad os komme i gang.

Git Rebase:

Lad os sige, du har et Git-arkiv med forpligtelserne EN, B, C i mestre afdeling. Derefter oprettede du en ny gren en gren og tilføjede 2 nye forpligtelser D og E til en gren afdeling.

Fig 1: oprindelig forpligtelseshistorik.

Lad os sige, du har glemt at tilføje noget i mestre afdeling. Så du går tilbage til mestre filial og tilføj en ny forpligtelse G til mestre afdeling. Din git-historie skal se ud som følger.

Fig 2: begivenhedshistorik efter tilføjelse af begivenhed G i mastergrenen.

Alt ser godt ud. Nu, hvis du ville have alle ændringer, du har foretaget i en gren gren at være i mestre filial, kan du fusionere en gren gren til mestre afdeling. Dette er hvad git fusionere gør.

Hvad hvis du vil have forpligtelsen G at være tilgængelig i en gren afdeling? Nå, du kan bruge git rebase til det.

Fra begivenhedshistorikken i fig. 2 kan du se, at grenen en gren starter fra begåelsen C. Hvis du laver en git-rebase på en gren, så ville det starte fra forpligtelsen G som vist i fig. 3 nedenfor. Bemærk, at indholdet af forpligtelsen D og E ændres også efter rebase-operationen. Det forpligter sig D og E vil omfatte ændringer i forpligtelse G. Dette er grunden til, at jeg tilføjede * symbolet inden det forpligter sig D og E.

Hvis du vil vide, hvordan forpligtelseshistorikken ville se ud, hvis jeg flettede den, så kig på fig 4. Jeg har inkluderet det bare, så du kan sammenligne det med git rebase.

Fig 4: begiv historie, hvis git-fletning blev brugt.

Nu hvor du ved, hvad der er git rebase, forskellen mellem git rebase og git merge og hvorfor git rebase det brugte, vil jeg vise dig, hvordan du bruger det i næste afsnit af denne artikel nedenfor.

Git Rebase Workflow:

I dette afsnit opretter jeg et nyt git-arkiv på min lokale computer og viser dig, hvordan git rebase fungerer. Jeg anbefaler, at du har en god forståelse af git rebase, før du anvender det på dit projekt.

Opret først et nyt Git-arkiv rebase-demo / på din computer som følger:

$ git init rebase-demo

Naviger nu til rebase-demo / katalog som følger:

$ cd rebase-demo /

Opret nu en ny fil prøve.txt som følger:

$ echo "A"> test.txt

Testen.txt-filen indeholder kun en linje EN. Lad os sige, dette er din oprindelige projektkode.

Foretag nu ændringerne som følger:

$ git tilføj .
$ git commit -m 'A'

Tilføj nu en ny linje B til prøve.txt fil som vist på skærmbilledet nedenfor.

Foretag nu ændringerne som følger:

$ git tilføj .
$ git commit -m 'B'

Lad os nu tilføje en anden linje C til prøve.txt fil.

Foretag også ændringerne som følger:

$ git tilføj .
$ git commit -m 'C'

Nu skal mastergrenens forpligtelseshistorik se ud som følger:

$ git log - online

Lad os sige, du har nogle nye ideer, som du vil prøve. Så lad os oprette og tjekke til en ny gren ny funktion som følger:

$ git checkout -b ny-funktion

Tilføj nu din nye idé (linjen D Lad os sige) til prøve.txt fil.

Foretag nu ændringerne som følger:

$ git tilføj .
$ git commit -m 'D'

Tilføj nu linien E til prøve.txt fil.

Foretag ændringerne som følger:

$ git tilføj .
$ git commit -m 'E'

Nu begår historien om ny funktion gren skal se ud som følger:

$ git log - online

Se, hvordan forpligtelserne er i rækkefølge A < B < C < D < E?

Nu husker du, at du har glemt at tilføje noget til mestre gren, som du også ville være i ny funktion afdeling! Så kassen til mestre afdeling.

Jeg tilføjede en ny linje i slutningen af prøve.txt fil, som du kan se.

Foretag nu ændringerne som følger:

$ git tilføj .
$ git commit -m 'G'

Nu begår historien om mestre gren skal se sådan ud.

EN < B < C < G

Nu for at rebase forpligtelserne fra mestre gren til ny funktion filial, første checkout til ny funktion afdeling.

$ git checkout ny-funktion

Gør nu en git-rebase af mestre gren som følger:

$ git rebase master

Nogle fusionerer konflikt! Lad os ordne det.

De ændringer, jeg har foretaget i forpligtelsen G og D er i konflikt med hinanden. Jeg vil beholde begge disse.

Efter løsning af fusionskonflikten, blev prøve.txt filen skal se ud som følger:

Tilføj nu ændringerne til mellemstationer som følger:

$ git tilføj .

Fortsæt nu rebasen, der fungerer som følger:

$ git rebase - fortsæt

En anden fusionskonflikt! Nå, dette kan ske. Rebase ændrer git commit-historikken. Så ting som dette forventes.

Det ser ud til, at fletningsprocessen mislykkedes på grund af nogle tomme linjer. Lad os ordne det.

Efter løsning af fusionskonflikten, prøve.txt filen skal se ud som følger.

Tilføj nu ændringerne til mellemstationer som følger:

$ git tilføj .

Fortsæt nu rebase-operationen som følger:

$ git rebase - fortsæt

Git rebase er komplet.

Som du kan se, opdateres forpligtelseshistorikken for den nye funktionsfilial. Nu er forpligtelseshistorikken som følger:

EN < B < C < G < D < E

Ligesom forventet.

Finalen prøve.txt filen skal se ud som følger.

Git rebase er et kraftfuldt værktøj. Men du skal aldrig bruge det til delte Git-arkiver. Brug det kun på Git-arkiverne, som du kun arbejder. Ellers vil du stå over for mange problemer undervejs.

Så det er sådan, du bruger git rebase. Tak, fordi du læste denne artikel.