Dela via


Tillämpa ändringar med ombasering

Azure DevOps Services | Azure DevOps Server 2022 – Azure DevOps Server 2019

Visual Studio 2019 | Visual Studio 2022

Git upprätthåller automatiskt en utvecklingshistorik för en gren genom att länka varje ny incheckning till sin föregångare. När du sammanfogar en gren till en annan kan historiken bli mindre enkel. Till exempel kombinerar en snabbsnabb koppling olika utvecklingslinjer genom att skapa en sammanslagning med flera föregående. På motsvarande sätt kombinerar en Git-ombas olika utvecklingslinjer utan att skapa en sammanslagningsincheckning, vilket resulterar i en enklare incheckningshistorik men förlorar information om sammanfogningen. Ditt val av sammanslagningstyp påverkas troligen av om du vill bevara en post för sammanfogningen eller förenkla incheckningshistoriken.

Den här artikeln beskriver när du ska använda en rebase i stället för en snabbsnabb sammanslagning och innehåller procedurer för följande uppgifter:

  • Ändra bas på din lokala gren
  • Tvinga fram push-överföring av din lokala gren efter en ombasering
  • Interaktiv ombasering för att krossa lokala incheckningar

En översikt över Git-arbetsflödet finns i Självstudie om Azure Repos Git.

Ändra bas på din lokala gren

Git-ombaseringen integrerar incheckningar från en källgren i din aktuella lokala gren (målgren). Källgrenen förblir oförändrad. Som jämförelse visas Git-ombasering och andra sammanslagningstyper i följande diagram.

Diagram som visar incheckningar före och efter när du använder Git-ombasering.

Git återställer incheckningshistoriken för målgrenen så att den innehåller alla källgrens incheckningar, följt av alla incheckningar av målgrenar sedan den senaste gemensamma incheckningen. Ett annat sätt att visa det är att en ombas spelar upp ändringarna i målgrenen ovanpå källgrenens historik. Git ändrar i synnerhet sekvensen för de befintliga incheckningarna för målgrenen, vilket inte är fallet för de andra sammanslagningsstrategierna. I föregående diagram innehåller commit K samma ändringar som K, men har ett nytt inchecknings-ID eftersom det länkar tillbaka till incheckningen E i stället för C.

Om en ändring av källgrenen står i konflikt med en ändring av målgrenen under en ombasering, uppmanar Git dig att lösa sammanslagningskonflikten. Du kan lösa sammanslagningskonflikter under en ombasering på samma sätt som du löser sammanslagningskonflikter under en sammanslagning.

Rebase kontra no-fast-forward merge

Git-ombasering resulterar i en enklare men mindre exakt incheckningshistorik än en snabbsnabb sammanslagning , även kallad en trevägs - eller sann sammanslagning. När du vill ha en post för en sammanslagning i incheckningshistoriken använder du en snabbsnabb koppling.

Om du är den enda som arbetar med en funktion eller en bugfix-gren kan du överväga att använda en ombas för att regelbundet integrera det senaste main grenarbetet i den. Den här strategin hjälper dig att hålla dig medveten om andras senaste arbete och snabbt lösa eventuella sammanslagningskonflikter som uppstår. Genom att ombasera implementerar du den nya funktionen ovanpå det senaste main grenarbetet, som hjälper till att upprätthålla en linjär incheckningshistorik.

Mer information om Git-ombasering och när du ska använda den finns i Rebase vs merge.

Ändra bas och framtvinga push-riktlinjer

Om du har ombaserat en lokal gren som du tidigare har push-överfört och sedan kör git push-standardkommandot igen misslyckas push-överföringen. Standardkommandot för Git-push tillämpar en snabbkoppling för att integrera din lokala gren i fjärrgrenen. Kommandot misslyckas efter en ombasering eftersom ombasen ändrar sekvensen av befintliga incheckningar i din lokala målgren, så att den inte längre matchar historiken för dess fjärrmotsvarighet. I det här scenariot lyckas en framtvinging – genom att skriva över fjärrgrenen.

Git-rebase och force push är kraftfulla verktyg, men tänk på dessa riktlinjer när du bestämmer dig för om du vill använda dem:

  • Ombaseras inte en lokal gren som har push-överförts och delats med andra, såvida du inte är säker på att ingen använder den delade grenen. Efter en ombasering matchar din lokala gren inte längre historiken för dess fjärrmotsvarighet.
  • Tvinga inte push-överföring till en fjärrgren som används av andra, eftersom deras lokala version av fjärrgrenen inte längre matchar den uppdaterade fjärrgrenshistoriken.
  • Ditt team bör komma överens om användningsscenarier för ombasering och framtvinga push-överföring.

Dricks

För en samarbetsgranskningsprocess använder du en pull-begäran för att sammanfoga nytt arbete till standardgrenen för en fjärrlagringsplats.

Så här gör du en ombasering

Visual Studio 2022 tillhandahåller en Git-versionskontroll med hjälp av Git-menyn , Git-ändringar och snabbmenyer i Solution Explorer. Visual Studio 2019 version 16.8 erbjuder även Användargränssnittet för Team Explorer Git. Mer information finns på fliken Visual Studio 2019 – Team Explorer .

  1. Välj Git > Hantera grenar för att öppna fönstret Git-lagringsplats .

    Skärmbild av alternativet Hantera grenar på Git-menyn i Visual Studio.

  2. I fönstret Git-lagringsplats högerklickar du på målgrenen och väljer Checkout.

    Skärmbild av alternativet Checkout i snabbmenyn för grenen i Fönstret Git-lagringsplats i Visual Studio.

  3. Högerklicka på källgrenen och välj Rebase target-branch> till <source-branch>.<

    Skärmbild av alternativet Rebase i snabbmenyn för grenen i Fönstret Git-lagringsplats i Visual Studio.

  4. Visual Studio visar ett bekräftelsemeddelande efter en lyckad ombasering.

    Skärmbild av bekräftelsemeddelandet för ombasering i Git-lagringsplatsens fönster i Visual Studio.

    Om ombasen stoppas på grund av sammanslagningskonflikter meddelar Visual Studio dig. Du kan antingen lösa konflikterna eller avbryta ombasen och återgå till förbaseringstillståndet.

    Skärmbild av återbaseringskonfliktmeddelandet i Git-lagringsplatsens fönster i Visual Studio.

Tvinga fram push-överföring av din lokala gren efter en ombasering

Om du har ombaserat en lokal gren som du tidigare har push-överfört misslyckas en efterföljande Git-push-standard. I stället kan du tvinga den lokala grenen att skriva över dess fjärrmotsvarighet så att deras incheckningshistorik matchar.

Varning

Tvinga aldrig fram en gren som andra arbetar med. Mer information finns i Ändra bas och framtvinga push-riktlinjer.

Om du vill framtvinga push-överföring i Visual Studio måste du först aktivera alternativet force push:

  1. Gå till Verktyg>alternativ>Källkontroll>Git Global Inställningar.

  2. Välj alternativet Aktivera push --force-with-lease.

Git-push-flaggan --force-with-lease är säkrare än flaggan eftersom den --force inte skriver över en fjärrgren som har incheckningar som inte är integrerade i den lokala gren som du tvingar fram push-överföring.

  1. I fönstret Git-ändringar väljer du push-knappen för att push-överföra incheckningen.

    Skärmbild av upppilens push-knapp i fönstret Git-ändringar i Visual Studio.

    Eller så kan du välja PushGit-menyn .

    Skärmbild av alternativet Push från Git-menyn i Visual Studio.

  2. Om standardåtgärden för Git-push misslyckas startar Visual Studio dialogrutan Git-Push misslyckades . Välj Framtvinga push.

    Skärmbild av dialogrutan Git-push misslyckades i Visual Studio.

  3. Visual Studio visar ett bekräftelsemeddelande efter en lyckad push-överföring.

    Skärmbild av push-bekräftelsemeddelandet i Visual Studio.

Interaktiv ombasering för att krossa lokala incheckningar

När du arbetar med en ny funktion i din lokala funktionsgren skapar du vanligtvis flera incheckningar. När du är redo att publicera den nya funktionen kanske du vill konsolidera incheckningarna till en enda incheckning för att förenkla incheckningshistoriken. Du kan använda en interaktiv ombas för att krossa flera incheckningar i en enda incheckning.

Visual Studio 2022 stöder inte interaktiv ombasering. Använd Git-kommandoraden i stället.

Kommentar

Azure DevOps-användare kan krossa sammanslagning för att komprimera incheckningshistoriken för en ämnesgren under en pull-begäran.

Nästa steg