Förgrening är en kärnfunktion i Git. Det är hur du kan arbeta med en viss funktion eller mjukvarukomponent utan att bryta din kod.
Det är möjligheten för dig som utvecklare att göra betydande ändringar i din källkod och välja vad du vill göra med ändringarna. Oavsett vilket kan du slå samman dem i eller kassera dem från hela projektet.
Om du har interagerat med Git, kanske du redan har märkt att det finns flera sätt att skapa grenar. Om du är en kommande utvecklare och inte har stött på Git än, kommer du att veta hur man använder versionskontrollverktyg sparar mycket tid; Om inte, gör din utvecklarupplevelse intressant.
Det här inlägget är taktiskt anpassat för att hjälpa dig att skapa Git-grenar smidigt som en del av ditt definierade arbetsflöde. I slutändan har du skaffat dig solida färdigheter som du kan använda för att underhålla dina GitHub-förråd.
Obs: Om du är en ny utvecklare, kolla in hur du konfigurerar ditt GitHub-konto innan du går vidare. Om du redan har gjort detta, gå till avsnittet hur man gör. Men en repetition skulle vara bra för att stärka din inlärning.
Innehållsförteckning
Vad är Git Branches?
Källa: atlassian.com
En gren i Git innebär en version av ditt arkiv som är avvikande från ditt huvudprojekt (tillgänglig i alla moderna versionskontrollsystem). Enkelt uttryckt, du kliver vid sidan av din huvudlinje för utveckling och arbetar utan att krångla med den ursprungliga linjen.
Många tillgängliga versionskontrollprogram (VCS)-verktyg använder denna teknik som innebär att du skapar en ny kopia av din källkodskatalog. När du hanterar större projekt kan det ta lite tid att replikera källkoden. På den ljusa sidan av saken är det din chans att experimentera med ändringar i din kod.
Gits förgreningsmodell anses vara en ”killer feature” och placerar Git på en egen nivå bland andra verktyg i VCS-gemenskapen. Git-operationsmodellen är enkel och gör förgreningsoperationer nästan omedelbara, och även växla mellan ett par eller flera. Om du behärskar Git-förgreningsmodellen låser du upp kraftfulla funktioner och verktyg som kan öka dina utvecklingsfärdigheter. Så, vad är grejen med grenar?
Varför du behöver Git-grenar
Git-grenar spelar en nyckelroll i Git-versionskontrollsystemet. Här är några anledningar till varför du behöver Git-grenar:
✅ Parallell utveckling – Modern mjukvara är komplex och många utvecklare arbetar ofta tillsammans för att bygga mjukvaran. Filialer tillåter olika utvecklare att arbeta med olika funktioner. I andra fall kan det vara att fixa buggar utan arbetskollisioner. Varje gren är en inkörsport till en ny utvecklingslinje. Du kan enkelt växla mellan grenar medan du arbetar med särskilda funktioner.
✅ Samarbete – Git-grenar låter dig arbeta med andra utvecklare på en gemensam kodbas. Du kan skapa nya grenar, göra kodändringar och skjuta dem till det delade arkivet, där andra utvecklare kan granska dina bidrag innan du slår ihop dem i huvudgrenen.
✅ Experiment – Du kan använda git-grenar för att testa nya funktioner innan du slår samman till och utan att påverka huvudgrenen. Det är din chans att prova ett nytt sätt att lösa ett problem. Och om de nya metoderna i din kod fungerar korrekt kan du slå ihop dem i huvudgrenen.
✅ Releasehantering – Du kan använda filialer för att hantera releaser. Du kan skapa varje gren kopplad till en specifik version i ditt arbetsprojekt. Detta gör att du kan fixa buggar och göra ändringar utan att påverka huvudutvecklingsgrenen.
✅ Versionering – Du kan använda Git-grenar för versionshantering; i detta fall kommer varje gren att representera en ny version av din programvara. Som utvecklare är det bäst att använda filialer för varje programvaruversion och spåra ändringar, som du använder för att hantera olika kodbasversioner.
Komma igång med Git – A Refresher
Nu när du förstår ”varför” är det dags att ta ett nytt skift och ta hand om ”hur”.
Framåt bör du redan ha konfigurerat ditt GitHub-konto. Om du fortfarande behöver, vänligen gör det. Det här avsnittet är praktiskt.
Kommandot git checkout i Git innebär att du byter mellan olika versioner av din målenhet. I vissa utvecklargemenskaper online hänvisar termen ”utcheckning” till utförandet av utcheckningskommandot. Detta kommando fungerar på tre enheter; filialer, filer och commits.
Kollar in en filial
Du kan använda kommandot git branch för att skapa grenar som du navigerar genom med git checkout. När du köper en filial uppdaterar du filerna i din arbetskatalog för att matcha versionen som lagras där.
Med andra ord, du säger åt Git att spela in alla dina commits i grenen (ändrar utvecklingslinjen). Att använda dedikerade grenar för nya funktioner i din utveckling är ett skifte från det gamla subversion-arbetsflödet (SVN) och gör det enkelt att arbeta med kod i alla instanser som är markerade i avsnittet Varför du behöver grenar.
Kommandot git checkout ska inte förväxlas med git clone. Den första används för att växla mellan kodversioner, medan den senare hämtar kod från ett fjärrlager.
Använda befintliga filialer
Om arkivet du arbetar med har befintliga grenar, kan du visualisera dem på ditt kommandoradsgränssnitt med hjälp av kommandot git branch.
De tillgängliga grenarna är listade, och den gröna är den du arbetar med för närvarande, förutsatt att du använder operativsystemet Windows och Visual Studio Code. För att växla mellan filialer, använd git checkout branchname. Frasen ”branchname” står för ditt filialnamn, och i din verksamhet kan du följa vilken namnkonvention som helst.
Skapa Git-grenar
Anta att du är mitt uppe i din mjukvaruutveckling och vill lägga till en ny funktion. Det bästa sättet att närma sig detta är att skapa en ny gren med hjälp av ’git branch’.
Praktiskt taget är detta vad du knappar in i kommandoraden:
git branch branchname
Det betyder att du har skapat en gren från huvud-/huvudgrenen (i de flesta fall är det här du kör ditt liveprojekt). Namnet på din nya filial, i det här fallet, är ”filialnamn”.
För att byta till din nya filial använder du git checkout ; se nedan:
git checkout branchname
Om du är en utvecklare, som gillar att spara tid som jag, kan du skapa en filial och omedelbart byta till den genom att använda ’git checkout’ med argumentet ’-b’ följt av ditt filialnamn. I praktiken kunde du bara ha gjort detta för att få liknande resultat som i våra tidigare steg, se:
git checkout -b branchname
Parametern ’-b’ säger åt Git att köra git-grenen precis innan du checkar ut den. Låt oss se andra tekniker som du kan använda för att skapa git-grenar.
Låt oss utforska fler tekniker som du kan använda för att skapa grenar baserat på dina behov:
#1. Skapa en filial från din nuvarande filial
Om du vill skapa en ny filial baserat på din nuvarande, är den bästa metoden att använda våra nyförvärvade kunskaper:
git checkout -b <branchname>
Denna metod skapar och växlar automatiskt till den nya grenen. För att bekräfta att du är på den nya filialen bör din terminal visa meddelandet – bytte till ett nytt filialnamn.
Om du är en ny utvecklare bör du vara angelägen om att knappa in kommandona på din konsol utan stag (<>). De är viktiga för illustration och förklaringar och bör inte förväxlas eller användas felaktigt.
#2. Skapa en gren från en annan gren
Du kan skapa en ny gren baserat på en annan befintlig gren genom att lägga till det grennamnet som utgångspunkt. Här är kommandot:
git branch <new branch> <base branch>
Och i ett praktiskt fall skulle det vara:
git branch new-branch branchname
Detta innebär att ”ny gren” är vår nya gren och ”grennamn” är vår bas (grund-)gren.
#3. Skapa en filial från ett åtagande
Om du vill basera din nya gren från en commit (och inte en gren), måste du ange commit-hash som utgångspunkt. Och för att hitta commit-hash, som du skapar grenen, kör git log .
commit-hash är vanligtvis en lång rad tecken som börjar med ’commit’. Med commit-hash kan du skapa den genom att köra kommandot:
git branch <branch name> <commit-hash>
Du kan sedan byta till din nya filial genom att kolla in den.
#4. Skapa en gren från en tagg
För att skapa en gren från en specifik tagg, leta reda på taggnamnet som du vill skapa en filial från. Kör kommandot git-tagg för att lista alla tillgängliga taggar i ditt arkiv.
När du har identifierat taggnamnet, kör git branch
#5. Skapa en gren med fristående HEAD State
Du kan använda ett fristående HEAD-tillstånd för att skapa nya grenar som börjar från en specifik commit utan att byta till den grenen omedelbart. Denna teknik är användbar när du vill experimentera med dina nya ändringar utan att påverka grenen du arbetar med. Börja med att hitta den commit-hash som du vill skapa branch-use git-loggen.
Med commit hash, kör: git checkout
#6. Skapa en gren från en fjärrgren
Börja med att skapa en lokal filial. Vid det här laget borde du vara bra på att använda: git checkout -b
Du skjuter en gren till fjärren genom att: git push origin
#7. Skapa en filial i ett fjärrlager
För att skapa en filial i ett fjärrlager, hämta de senaste ändringarna från din fjärrrepo genom att köra kommandot git fetch. Efter att ha fått de senaste uppdateringarna kan du skapa en ny filial genom att kolla in den. Och efter att ha checkat ut kan du driva de nya ändringarna genom att:
git push -u <remote repo> <new branch name>
I din verksamhet skulle det vara bäst att använda ursprung (som hur du skapade en gren från en fjärrgren). Det sparar tid och minskar risken för ett fel när du skriver in namnen på dina fjärrrepo.
GitHub Online-gränssnitt
Alla uppgifter som görs på kommandoraden kan replikeras med hjälp av kommandoradsgränssnittet. För att skapa en ny gren, gå till din projektförrådssida och leta efter grenar i den övre vänstra kanten – ofta master/main.
Om du klickar på den kommer en lista över dina tillgängliga filialer att visas nedan, ett textfält som du kan använda för att hitta eller skapa en filial.
För att skapa en gren, skriv dess namn i textfältet. Onlinegränssnittet är automatiserat och låter dig skapa grenar från specifika element som taggar, grenar och commits. Och om du är ny på förgrening kan en kolla in GitHubs filialdokument spara dig problem i framtida utvecklarsträvanden.
Slutord
Efter att ha lärt dig flera tekniker för att skapa Git-grenar, kan du nu införliva dina nyförvärvade färdigheter i din mjukvaruutveckling med ett smidigt Git-arbetsflöde.
Det bästa förgreningsalternativet kommer att förlita sig mycket på ditt team: arbetsflödeskriterier och händelseförekomster. Om du till exempel ber om en samarbetspartners input, kan de skapa filialer på distans och markera ovärderliga bidrag.
Du har sett hur Git branching ger dig en kraftfull mekanism för att arbeta mer effektivt och effektivt med programvaruprojekt. Och medan det finns andra Git-kontrollalternativ, har det här inlägget visat dig hur du navigerar dig med Git-grenar på kommandoraden, och jag får dig att känna dig mer säker när du använder Git.
Efter att ha befäst din konst i att skapa grenar, skulle du vara mer glad över att kolla in vår guide om att ta bort GitHub-grenar.