Förgrena och sammanfoga dina ändringar
När du arbetar med Bicep-kod är det vanligt att behöva göra mer än en sak i taget. Här är till exempel två scenarier för att arbeta med leksaksföretagets webbplats:
- Webbplatsens utvecklingsteam vill ha hjälp med att uppdatera Bicep-filer med betydande ändringar. Teamet vill dock inte att dessa ändringar ska gå live än. Du måste kunna göra mindre justeringar av den aktuella liveversionen av webbplatsen parallellt med arbetet med den nya versionen.
- Du arbetar med experimentella ändringar som du tror kommer att bidra till att förbättra webbplatsens prestanda. Dessa ändringar är dock preliminära. Du vill inte tillämpa dem på liveversionen av webbplatsen förrän du är klar.
I den här lektionen lär du dig mer om Git-grenar.
Kommentar
Kommandona i den här enheten visas för att illustrera begrepp. Kör inte kommandona än. Du kommer att öva på det du lär dig här snart.
Vad är grenar?
En gren är ett sätt att ha flera aktiva kopior av dina filer. Du kan skapa och växla mellan grenar när du vill. När du är klar med att arbeta med en gren kan du sammanfoga den till en annan gren. Du kan också ta bort den, vilket tar bort alla ändringar.
Det är vanligt att använda grenar för allt ditt arbete. Ofta anger du en gren som den primära grenen som representerar den kända goda versionen eller liveversionen av dina filer. Enligt konventionen kallas den här grenen vanligtvis main. Du kan skapa valfritt antal andra grenar. När dina ändringar på en gren är klara sammanfogar du grenen till huvudgrenen.
Skapa och checka ut en gren
Det går snabbt och enkelt att skapa en gren i Git. Det finns några sätt att göra det på, men det enklaste sättet är vanligtvis att använda git checkout kommandot. Här är ett exempel på hur vi skapar en ny gren med namnet my-experimental-changes:
git checkout -b my-experimental-changes
Det här kommandot gör faktiskt två saker: det skapar grenen my-experimental-changes och checkar ut den nyligen skapade grenen. En utcheckning innebär att kopian av filerna som du ser i mappen återspeglar vad som finns i grenen. Om du har två grenar med olika uppsättningar med ändringar kan du checka ut en gren och sedan den andra så att du kan växla mellan de två uppsättningarna med ändringar.
Du kan växla till en befintlig gren med hjälp git checkout av kommandot också. I det här exemplet checkar du ut huvudgrenen:
git checkout main
Kommentar
Normalt behöver du checka in ändringarna innan du kan checka ut en annan gren. Git varnar dig om du inte kan checka ut.
Arbeta med en gren
När du har växlat till en gren checkar du in filer precis som vanligt. Faktum är att allt du har gjort hittills har varit på en gren. Du arbetade med huvudgrenen, som är standardgrenen när du skapar en ny lagringsplats.
När du checkar in några ändringar medan du har checkat ut en gren associeras incheckningen med grenen. När du växlar till en annan gren ser du förmodligen inte incheckningen i historiken git log förrän du sammanfogar grenen.
Sammanfoga grenar
Grenar är ett bra sätt att skilja ditt pågående arbete från den aktuella liveversionen av din Bicep-kod. Men när du har gjort ändringar i dina filer på en gren vill du ofta sammanfoga ändringarna tillbaka till huvudgrenen.
När du arbetar med en gren kan du sammanfoga en annan grens ändringar i den aktuella grenen git merge med hjälp av kommandot .
Kommentar
Se till att checka ut målgrenen för sammanslagning (kallas ofta målgrenen) innan du sammanfogar. Kom ihåg att du sammanfogar från en annan gren till din aktuella arbetsgren.
Här är ett exempel som visar hur du kan checka ut huvudgrenen och sedan sammanfoga ändringarna från grenen my-experimental-changes till huvudgrenen. Slutligen tar du bort grenen my-experimental-changes eftersom du inte längre behöver den.
git checkout main
git merge my-experimental-changes
git branch -d my-experimental-changes
Dricks
När du arbetar med andra är det vanligt att använda pull-begäranden för att sammanfoga dina ändringar i stället för att slå samman grenar direkt. Du lär dig mer om samarbete och pull-begäranden inom kort.
Sammanslagningskonflikter
När Git sammanfogar ändringar från en gren till en annan, tittar den på de filer som har ändrats och försöker sammanfoga ändringarna. Ibland kan du ha gjort ändringar i samma kodrader på två olika grenar. I dessa situationer kan Git inte välja vilken som är rätt version av koden, så det skapar i stället en sammanslagningskonflikt.
Vi diskuterar inte sammanslagningskonflikter på djupet i den här modulen, men det är viktigt att veta att sammanslagningskonflikter kan inträffa. Och det är vanligare när du samarbetar med andra. I sammanfattningen för den här modulen tillhandahåller vi en länk till mer information om hur Git och Visual Studio Code hjälper dig att lösa sammanslagningskonflikter.
Git-arbetsflöden
I den här modulen lär du dig bara om grunderna i grenar. Grenar är dock kraftfulla och ger dig flexibilitet i hur du arbetar. Du kan till exempel skapa grenar från andra grenar och slå samman en gren med en annan gren. Du kan använda grenar för att skapa alla typer av olika arbetsflöden som stöder hur du och ditt team gillar att arbeta.
I den här modulen använder vi ett enkelt arbetsflöde som kallas trunkbaserad utveckling. I det här arbetsflödet har du en enda stamgren . Vi använder till exempel main i den här artikelns exempel. Den grenen representerar den kända versionen av koden. Du skapar grenar från den här stammen när du gör ändringar eller utför något arbete.
Trunkbaserad utveckling avråder från att göra ändringar direkt på stamgrenen. Du försöker bara behålla andra grenar under en kort tid, vilket hjälper till att minimera sammanslagningskonflikter. Sedan sammanfogar och tar du bort grenarna när du slutför arbetet.
Det finns andra arbetsflöden som är vanliga i teammiljöer där du kanske vill styra hur ofta du släpper ändringarna. I sammanfattningen för den här modulen tillhandahåller vi länkar till mer information om Git-arbetsflöden.