Om grenar och grenprinciper

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

Grenprinciper är en viktig del av Git-arbetsflödet och gör att du kan:

• Isolera pågående arbete från det slutförda arbetet i huvudgrenen
• Garantera att ändringar skapas innan de kommer till huvudversionen
• Begränsa vem som kan bidra till specifika grenar
• Framtvinga vem som kan skapa grenar och namngivningsriktlinjerna för grenarna
• Inkludera automatiskt rätt granskare för varje kodändring
• Tillämpa metodtips med nödvändiga kodgranskare

I följande tabell sammanfattas de principer som du kan definiera för att anpassa en gren. En översikt över alla principer och inställningar för lagringsplats och gren finns i Inställningar och principer för Git-lagringsplats.

Använda en förgreningsstrategi på Git

Det finns några viktiga grenar på din lagringsplats som teamet förlitar sig på att alltid vara i god form, till exempel din main gren.

Kräv pull-begäranden för att göra ändringar i dessa grenar. Utvecklare som push-överför ändringar direkt till de skyddade grenarna får sina push-meddelanden avvisade.

Håll din grenstrategi enkel genom att bygga din strategi utifrån dessa tre begrepp:

1. Använd funktionsgrenar för alla nya funktioner och buggkorrigeringar.
2. Sammanfoga funktionsgrenar till huvudgrenen med hjälp av pull-begäranden.
3. Håll en uppdaterad huvudgren av hög kvalitet.

En strategi som utökar dessa begrepp och undviker motsägelser resulterar i ett arbetsflöde för versionskontroll för ditt team som är konsekvent och lätt att följa.

• Anta en förgreningsstrategi
• Så här konfigurerar du grenprinciper
• Grenbehörigheter
• Kräv grenmappar
• Konfigurera en grenprincip för en extern tjänst

Skapa arbete i grenar

Git-grenar är inte mycket mer än en liten referens som behåller en exakt historik över incheckningar, så de är billiga att skapa.

Att göra ändringar i en gren påverkar inte andra grenar. Du kan dela grenar med andra utan att behöva koppla ändringarna till huvudprojektet.

Du kan skapa nya grenar för att isolera ändringar för en funktion eller en felkorrigering från huvudgrenen och annat arbete.

Eftersom grenarna är lätta är det snabbt och enkelt att växla mellan grenar. Git skapar inte flera kopior av källan när du arbetar med grenar – den använder historikinformationen som lagras i incheckningar för att återskapa filerna på en gren när du börjar arbeta med den.

Ditt Git-arbetsflöde bör skapa och använda grenar för att hantera funktioner och felkorrigeringar.

Resten av Git-arbetsflödet, till exempel delningskod och granskning av kod med pull-begäranden , fungerar alla via grenar.

Att isolera arbete i grenar gör det enkelt att ändra det du arbetar med genom att ändra din aktuella gren.

Hur skapas Git-grenar?

Du skapar grenar med hjälp branch av kommandot . Branch skapar en referens i Git för den nya grenen och en pekare tillbaka till den överordnade incheckningen så att Git kan behålla en historik över ändringar när du lägger till incheckningar i grenen.

När du arbetar med en gren som någon annan har delat behåller Git en överordnad spårningsrelation. Relationen associerar grenen på den lokala lagringsplatsen med motsvarande gren på fjärrplatsen.

Uppströmsspårning gör det enkelt att synkronisera ändringar med andra med push och pull.

I den här skärmbilden kan du se en ny gren som har skapats från huvudgrenen. Arbetet fortsätter på båda grenarna och incheckningar läggs till i båda grenarna.

Git lägger alltid till nya incheckningar i den aktuella lokala grenen. Kontrollera vilken gren du arbetar med innan du checkar in så att du inte checkar in ändringar i fel gren.

Växla mellan lokala grenar med kommandot checkout . Git ändrar filerna på datorn så att de matchar den senaste incheckningen på den utcheckade grenen.

När ditt arbete i grenen är redo att dela med resten av teamet skickar du ändringarna för att uppdatera fjärrgrenen.

Ett vanligt misstag är att göra vissa ändringar och commit dem, inse att du är på en felaktig gren och sedan checkout till rätt gren.

De senaste ändringarna finns inte längre i filsystemet eftersom varje gren har en egen kodversion.

Git för tillbaka filernas tillstånd till den senaste incheckningen på den gren som du bytte till, inte den föregående grenen där du gjorde dina ändringar.

Du måste antingen välja incheckningarna från grenen eller sammanfoga ändringarna till rätt gren.

Använda grenar för att hantera utveckling

Git håller reda på vilken gren du arbetar med och ser till att när du checkout en gren dina filer matchar den senaste incheckningen på grenen.

Med grenar kan du arbeta med flera versioner av källkoden på samma lokala Git-lagringsplats samtidigt.

Tala om för Git vilken gren du vill arbeta med och checkoutGit tar hand om att ange rätt filversioner för den grenen.

Du behöver inte mer än en lagringsplats i systemet när du använder grenar för att isolera ditt arbete.

Konfigurera utvecklingsmiljön en gång efter kloningen. Använd sedan Git-grenar för att växla mellan funktionsarbete och felkorrigering.

Instruktionsguider om förgrening

Lär dig hur du utför vanliga uppgifter när du arbetar med grenar.

• Självstudie om grenar
• Så här skapar du en gren
• Så här tar du bort en gren
• Återställa en borttagen gren
• Så här låser du grenar

Relaterade artiklar

• Förbättra kodkvaliteten med grenprinciper
• Inställningar och principer för Git-lagringsplats
• Konfigurera Principer för Git-lagringsplats med hjälp av en konfigurationsfil
• Git-standardbehörigheter (säkerhet)
• Ange behörigheter (säkerhet)
• Översikt över integrering mellan tjänster