introduktion till Git rebase, force-push och merge conflicts

• Git rebase
  • före rebasing
  • Regular rebase
  • Interactive rebase
• Force-push
• sammanfoga konflikter

den här guiden hjälper dig att komma igång med rebasing, Force-pushing och fixingmerge konflikter lokalt.

innan du dyker in i det här dokumentet, se till att du är bekant med att användagit via kommandoraden.

Git rebase

Rebasing är en mycket vanlig operation inGit., Det finns följande rebase alternativ:

• Regular rebase.
• interaktiv rebase.

innan du rebaserar

det är säkrare att säkerhetskopiera din gren innan du rebaserar för att se till att du inte förlorar några ändringar. Till exempel överväga en funktion branchcalled my-feature-branch:

1. öppna din funktion gren i terminalen:

   git checkout my-feature-branch

2. kassan en ny gren från det:

   git checkout -b my-feature-branch-backup

3. gå tillbaka till din ursprungliga gren:

   git checkout my-feature-branch

nu kan du säkert göra om det., Om något går fel kan du återställa yourchanges genom att återställa my-feature-branch mot my-feature-branch-backup:

Observera att om du har lagt till ändringar i my-feature-branch efter att ha skapat säkerhetskopian förlorar du dem när du återställer.

Regular rebase

med en vanlig rebase kan du uppdatera din funktion gren med defaultbranch (eller någon annan gren).Detta är ett viktigt steg för Git-baserade utvecklingsstrategier., Du kan försäkra dig om att ändringarna du lägger till i kodbasen inte bryter mot några befintliga ändringar som lagts till i målgrenen efter att du skapat din featurebranch.,

For example, to update your branch my-feature-branch with master:

1. Fetch the latest changes from master:

   git fetch origin master

2. Checkout your feature branch:

   git checkout my-feature-branch

3. Rebase it against master:

   git rebase origin/master

4. Force-push to your branch.,

När du rebase:

1. Git importerar alla åtaganden som lämnats till master efter themoment skapade du din funktion gren fram till nuet.
2. Git sätter de åtaganden du har i din funktion gren ovanpå allthe begår importeras från master:

Du kan ersätta master med någon annan gren du vill göra om mot, till exempel release-10-3., Du kan också ersätta origin med andra remoterepositorier, till exempel upstream. För att kontrollera vilka fjärrkontroller du har länkat till din localrepository kan du köra git remote -v.

om det finns sammanfogningskonflikter, uppmanar Git dig att fixa dem innan du fortsätter rebasen.

Läs mer om Git: s dokumentation om rebasing and rebasing strategies.

Interactive rebase

Du kan använda interactive rebase för att ändra begår. Till exempel, ändra en commitmessage, squash (gå flera begår i en), redigera eller deletecommits., Använd en rebase för att ändra tidigare begå meddelanden och organisera begå historia din gren för att hålla den ren.

När du vill ändra något under de senaste åtagandena, använd interactiverebase genom att skicka flaggan--interactive (eller-i) till kommandot rebase.,

om du till exempel vill redigera de tre sista åtagandena i din gren (HEAD~3), kör:

git rebase -i HEAD~3

Git öppnar de tre sista åtagandena i din terminal textredigerare och beskriver alla interaktiva rebase-alternativ du kan använda. Standardalternativet är pick, som bibehåller begå oförändrat. Ersätt sökordet pick enligt den åtgärd du vill utföra i varje begå. För att göra det måste du redigeraförbindelserna i terminalens textredigerare.,

till exempel, om du använder Vim som textredigerare ina macOS ZSH skal, och du vill squash alla tre begår(gå med dem i en):

1. Tryck ion tangentbordet för att växla till Vim redigeringsläge.
2. navigera med dina tangentbordspilar för att redigera den andra commit keywordfrom picktillsquash(ellers). Gör samma sak med den tredje förbindelsen.Den första begå bör lämnas oförändrad (pick) som vi vill squashden andra och tredje till den första.,
3. tryck på Escape för att lämna redigeringsläget.
4. skriv:wq för att ”skriva” (spara) och ”avsluta”.
5. Git matar ut commit-meddelandet så att du har en chans att redigera det:
   • alla linjer som börjar med# ignoreras och ingår inte i commitmessage. Allt annat ingår.
   • för att lämna det som det är, skriv:wq. För att redigera begå meddelande: växla tillredigeringsläge, redigera begå meddelandet och spara det som du just gjorde.,
6. Om du inte har drivit dina åtaganden till fjärrgrenen innan du gör om,tryck på dina ändringar normalt. Om du hade drivit dessa begår redan, force-push istället.

Observera att stegen för redigering via kommandoraden kan vara någotolika beroende på ditt operativsystem och det skal du använder.

se många ångra möjligheter i Gitfor en djupare titt på interaktiva rebase.,

Force-push

När du utför mer komplexa operationer, till exempel, squash begår, återställa orrebase din gren, måste du tvinga en uppdatering till fjärrgrenen.Dessa operationer innebär att skriva om begå historia branch.To tvinga en uppdatering, skicka flaggan --force eller -f till kommandot push. Exempel:

git push --force origin my-feature-branch

det rekommenderas inte att tvinga fram en uppdatering när du arbetar med sharedbranches.

Alternativt kan du skicka flaggan--force-with-leaseistället., Det är säkrare, eftersom det inte skriver över något arbete på remotebranch om fler åtaganden tillsattes till fjärrgrenen av någon annan:

git push --force-with-lease origin my-feature-branch

om grenen du vill tvinga-push är skyddad kan du inte tvinga-push till det om du inte avskyddar det först. Då kan dutvinga-tryck och skydda det igen.,

sammanfoga konflikter

eftersom Git bygger på att jämföra versioner av en fileline-by-line, när en rad ändras i din gren sammanfaller med sameline ändras i målgrenen (efter det ögonblick du skapade din funktion gren från det), Gitidentifierar dessa förändringar som en sammanfogningskonflikt. För att fixa det måste du väljavilken version av den linjen du vill behålla.

de flesta konflikter kan lösas genom GitLab UI.

För mer komplexa fall finns det olika metoder för att lösa dem. Det finnsäven Git GUI-appar som kan hjälpa till attvisualisera skillnaderna.,

för att åtgärda konflikter lokalt kan du använda följande metod:

1. öppna terminalen och kassan din funktion gren, till exempelmy-feature-branch:

   git checkout my-feature-branch

2. Rebase din gren mot målgrenen så Gitprompts dig med konflikterna:

   git rebase origin/master