Grenhantering är en grundläggande funktion i Git. Det gör det möjligt för dig att arbeta med en specifik funktion eller programvarukomponent utan att riskera att påverka den befintliga koden.
Som utvecklare ger det dig möjligheten att göra betydande ändringar i din källkod och bestämma hur du ska hantera dessa ändringar. Du kan välja att integrera dem i projektet eller ta bort dem helt.
Om du redan har erfarenhet av Git, har du säkert märkt att det finns flera metoder för att skapa grenar. Om du är en nybliven utvecklare och ännu inte har stött på Git, kommer du snart att upptäcka hur tidsbesparande versionshanteringsverktyg är. Om inte, kommer det garanterat att göra din utvecklingsupplevelse mer spännande.
Den här guiden är utformad för att hjälpa dig att effektivt skapa Git-grenar som en integrerad del av din arbetsmetodik. Genom att lära dig dessa färdigheter kommer du att kunna underhålla dina GitHub-förråd på ett professionellt sätt.
Notera: Om du är nybörjare rekommenderas att du skapar ett GitHub-konto innan du går vidare. Om du redan har gjort det, kan du hoppa direkt till avsnittet om hur man gör. En snabb genomgång kan dock vara bra för att förstärka dina kunskaper.
Vad är Git-grenar?
Källa: atlassian.com
I Git representerar en gren en version av ditt arkiv som avviker från huvudprojektet. Det kan liknas vid att kliva åt sidan från huvudutvecklingslinjen för att arbeta utan att störa den ursprungliga koden.
Många moderna versionshanteringssystem (VCS) använder denna teknik, vilket innebär att en ny kopia av din källkodskatalog skapas. När du arbetar med stora projekt kan detta ta lite tid. Fördelen är att du får möjligheten att testa nya ändringar i din kod på ett säkert sätt.
Gits grenhanteringsmodell anses vara en ”killer feature” som skiljer Git från andra VCS-verktyg. Git-operationerna är enkla, vilket gör det snabbt att både skapa och växla mellan grenar. Genom att bemästra Gits grenhantering låser du upp kraftfulla funktioner som kan förbättra dina utvecklingsfärdigheter. Så, vad är egentligen grejen med grenar?
Varför du behöver Git-grenar
Git-grenar är en central del av Gits versionshanteringssystem. Här är några skäl till varför du behöver dem:
✅ Parallell utveckling – Dagens mjukvara är komplex och kräver ofta att flera utvecklare samarbetar. Grenar tillåter olika utvecklare att arbeta med olika funktioner eller buggfixar utan att det uppstår konflikter. Varje gren fungerar som en separat utvecklingslinje och du kan smidigt växla mellan grenar när du arbetar med specifika uppgifter.
✅ Samarbete – Git-grenar underlättar samarbete mellan utvecklare på samma kodbas. Du kan skapa nya grenar, genomföra kodändringar och skicka dem till det delade arkivet. Andra utvecklare kan granska dina bidrag innan de slås samman med huvudgrenen.
✅ Experiment – Git-grenar ger dig en säker miljö för att testa nya funktioner utan att riskera stabiliteten i huvudgrenen. Det ger dig möjligheten att utforska alternativa lösningar. Om de nya metoderna fungerar kan du enkelt integrera dem med huvudgrenen.
✅ Releasehantering – Grenar kan användas för att hantera olika releaser av din mjukvara. Du kan skapa en specifik gren för varje version av ditt projekt, vilket underlättar hantering av buggfixar och ändringar utan att störa huvudutvecklingslinjen.
✅ Versionshantering – Git-grenar underlättar versionshantering genom att varje gren kan representera en ny version av din mjukvara. Det är en bra metod att använda grenar för varje version och på så sätt kunna spåra ändringar och hantera olika kodbasversioner.
Komma igång med Git – En repetitionskurs
Nu när du förstår ”varför” är det dags att fokusera på ”hur”.
Vi antar att du redan har konfigurerat ditt GitHub-konto. Om inte, rekommenderar vi att du gör det nu. Det här avsnittet kommer att vara praktiskt.
Git-kommandot git checkout används för att växla mellan olika versioner i ditt förråd. Termen ”utcheckning” avser ofta själva utförandet av detta kommando. Kommandot fungerar på tre nivåer: grenar, filer och commits.
Utcheckning av en gren
Kommandot git branch används för att skapa grenar som du navigerar mellan med git checkout. När du ”checkar ut” en gren uppdateras filerna i din arbetsmapp för att matcha den version som är lagrad i grenen.
Du talar om för Git att registrera alla dina commits i den specifika grenen, vilket ändrar utvecklingslinjen. Att använda separata grenar för nya funktioner skiljer sig från det äldre SVN-systemet och underlättar hantering av kod i alla de situationer som nämns i avsnittet ”Varför du behöver grenar”.
Kommandot git checkout ska inte förväxlas med git clone. Det första används för att växla mellan kodversioner medan det senare hämtar kod från ett fjärrlager.
Använda befintliga grenar
Om det finns befintliga grenar i det arkiv du arbetar med, kan du visa dem i ditt kommandoradsgränssnitt med git branch.
De tillgängliga grenarna listas, och den som är grön är den du för närvarande arbetar med (om du använder Windows och Visual Studio Code). För att växla mellan grenar använder du git checkout branchname. ”branchname” står för namnet på din gren, och du kan använda valfri namnkonvention för dina grenar.
Skapa Git-grenar
Anta att du är mitt i mjukvaruutvecklingen och vill lägga till en ny funktion. Det bästa sättet att göra det är att skapa en ny gren med git branch.
I praktiken skriver du följande i kommandoraden:
git branch branchname
Detta innebär att du har skapat en gren från huvudgrenen (där du oftast har ditt liveprojekt). Namnet på din nya gren är ”branchname”.
För att byta till din nya gren använder du git checkout, som nedan:
git checkout branchname
Om du, som många utvecklare, vill spara tid kan du skapa en gren och direkt byta till den med git checkout och argumentet -b, följt av ditt grennamn. I praktiken hade du kunnat göra detta istället för de föregående stegen:
git checkout -b branchname
Parametern -b talar om för Git att utföra git branch-kommandot innan du gör en utcheckning. Låt oss se andra tekniker du kan använda för att skapa Git-grenar.
Låt oss utforska fler tekniker för att skapa grenar utifrån dina behov:
#1. Skapa en gren från din aktuella gren
Om du vill skapa en ny gren baserad på den nuvarande grenen, är den bästa metoden att använda det du nyligen har lärt dig:
git checkout -b <branchname>
Denna metod skapar automatiskt den nya grenen och växlar till den. För att bekräfta att du är i den nya grenen bör terminalen visa ett meddelande som bekräftar att du bytt till den nya grenen.
Som ny utvecklare är det viktigt att du inte förväxlar parenteserna (< >) i kommandona. De är där för att förklara och illustrera och ska inte användas direkt i terminalen.
#2. Skapa en gren från en annan gren
Du kan skapa en ny gren baserad 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 ett konkret exempel skulle vara:
git branch new-branch branchname
Detta betyder att ”new-branch” är vår nya gren och ”branchname” är vår basgren.
#3. Skapa en gren från en commit
Om du vill skapa en ny gren baserad på en commit (och inte en gren), måste du ange commit-hash som utgångspunkt. För att hitta commit-hash som du skapar grenen från kör du git log.
Commit-hash är vanligtvis en lång rad tecken som börjar med ’commit’. Med commit-hash kan du skapa grenen genom att köra kommandot:
git branch <branch name> <commit-hash>
Sedan kan du växla till den nya grenen genom att checka ut 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 basera din nya gren på. Kör kommandot git tag för att visa alla tillgängliga taggar i ditt arkiv.
När du har identifierat taggnamnet kör du: git branch <new branch> <tag name>. Därefter kan du byta till din nya gren och börja göra kodändringar.
#5. Skapa en gren med fristående HEAD-tillstånd
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 växla till den grenen direkt. Den här tekniken är användbar när du vill experimentera med nya ändringar utan att påverka den gren du arbetar med. Börja med att hitta commit-hash som du vill använda med git log.
Med commit-hash kör du: git checkout <commit hash>. Det här kommandot innebär att du är i ett fristående HEAD-tillstånd, vilket betyder att du inte är i en gren utan pekar på en specifik commit. Därefter kan du använda git branch <branch name> för att skapa en gren baserad på din nuvarande commit.
#6. Skapa en gren från en fjärrgren
Börja med att skapa en lokal gren. Vid det här laget bör du känna till kommandot: git checkout -b <branchname>. Fjärrgrenen skapas automatiskt när du skickar den lokalt skapade grenen till fjärrarkivet.
Du skickar en gren till fjärrarkivet med: git push origin <branch name>. I detta kommando står ’origin’ för det fjärrarkiv som du skickar ändringar till. Du kan ersätta det med namnet på ditt fjärrarkiv, det fungerar lika bra.
#7. Skapa en gren i ett fjärrlager
För att skapa en gren i ett fjärrlager, hämtar du de senaste ändringarna från fjärrarkivet med kommandot git fetch. När du har fått de senaste uppdateringarna kan du skapa en ny gren genom att checka ut den. Och efter att ha checkat ut kan du skicka dina ändringar med:
git push -u <remote repo> <new branch name>
För de flesta fall rekommenderas att du använder ’origin’ (som när du skapar en gren från en fjärrgren). Det sparar tid och minskar risken för fel när du skriver in namnen på dina fjärrarkiv.
GitHub Online-gränssnitt
Alla uppgifter som görs via kommandoraden kan även utföras med hjälp av GitHubs onlinegränssnitt. För att skapa en ny gren, gå till ditt projekts arkivsida och leta efter grenarna i det övre vänstra hörnet, ofta master eller main.
Om du klickar på den kommer en lista över dina tillgängliga grenar att visas, tillsammans med ett textfält som du kan använda för att söka efter eller skapa en gren.
För att skapa en gren, skriv in dess namn i textfältet. Onlinegränssnittet är automatiserat och låter dig skapa grenar från specifika element som taggar, grenar och commits. Om du är nybörjare kan GitHubs dokumentation om grenar hjälpa dig i din framtida utveckling.
Slutord
Efter att ha lärt dig olika metoder för att skapa Git-grenar kan du nu integrera dina nyvunna färdigheter i din mjukvaruutveckling med ett smidigt Git-arbetsflöde.
Den bästa grenstrategin beror på ditt team, arbetsflödeskrav och situation. Om du till exempel vill få feedback från en kollega, kan de skapa grenar på distans och dela med sig av sina bidrag.
Du har sett hur Git-grenar ger dig ett effektivt verktyg för att arbeta mer smidigt med programvaruprojekt. Även om det finns andra Git-kontrollmetoder, har det här inlägget visat dig hur du hanterar Git-grenar via kommandoraden, vilket kommer att öka ditt självförtroende när du använder Git.
När du har bemästrat konsten att skapa grenar kan det vara bra att lära sig hur man tar bort grenar.
Kolla in vår guide om att ta bort GitHub-grenar.