Hur man använder Git-grenar för att strukturera ditt programmeringsprojekt

Filmer och tv visar programmering som en häftig aktivitet Hollywood Hacks: Den bästa och sämsta hackningen i filmer Hollywood Hacks: Den bästa och sämsta hackningen i filmer Hollywood och hacking klarar inte. Medan hacking i verkligheten är svårt, involverar filmhackning ofta bara att pounda på ett tangentbord som att dina fingrar går ur stil. Läs mer . En bombs timer räknas ner, och den nerdiga sidekicken som var en börda fram till den punkten fungerar febrilt på en bärbar dator. Koden flyger över skärmen tills hon träffar den slutliga returnyckeln med en tillfredsställande klack! Timern slutar, och allt är rätt i världen igen. Men programmering är inget sådant. Den innehåller designdokument, UI-mock-ups och kodrecensioner. Och mer än vad som helst, det handlar om trial-and-error, speciellt om du är nybörjare (som jag).

Nu kan du redan vara övertygad om värdet av att hålla dina kodprojekt i källkontrollen. Vad är Git och varför du bör använda Versionsstyrning Om du är en utvecklare Vad är Git och varför du bör använda Versionsstyrning Om du är utvecklare Som webbutvecklare, lägger vi mycket tid på att arbeta på lokala utvecklingsplatser, så ladda bara upp allt när vi är klara. Det här är bra när det bara är du och förändringarna är små, ... Läs mer. Att begå allt detta försök och fel till ditt förråd kommer att göra för ett stort och osjämt projekt, med många ändringar. De flesta av de förpliktelser du gör kommer att innehålla saker som är trasiga, så varför spara det? Git gren funktionen kan hjälpa till att hålla all denna röriga koden borta från de saker du vet fungerar.

I den här artikeln ser vi på vilken förgrening din kod betyder, hur man gör det och hur man hanterar uppdateringar till “huvud” gren.

Skapa en Git Branch

Vi har lärt oss av vår introduktion till källkontroll Hantera din filversion Som en programmerare med Git Hantera din versionsversion som en programmerare med Git Programmerare skapade versionskontrollsystem (VCS) för att lösa filversionsstyrproblem. Låt oss titta på grunderna för versionskontroll med dagens toppsystem, Git. Läs mer om att du kan skapa ett nytt förråd med följande kommando i en terminal:

git init

När du gör det skapas det en dold katalog i din nuvarande sökväg, kallad “.git.” Om du inte kan se det, se några av våra tidigare artiklar om visning av dolda Det enkla sättet att visa dolda filer och mappar i Windows 10, 8.1 och 7 Det enkla sättet att visa dolda filer och mappar i Windows 10, 8.1 och 7 Behöver du se dolda filer och mappar i Windows? Så här visar du dem i Windows 10, 8.1 och 7 så att ingenting är dolt för dig. Läs mer filer Dölj och hitta vilken fil som helst på Mac OS X Dölj och hitta vilken fil som helst på Mac OS X Det finns inget enkelt sätt att snabbt dölja eller avslöja dolda filer på Mac OS X som finns på Windows - men det är möjligt. Läs mer . Den här katalogen innehåller all information som behövs för att behålla revisionshistoriken för dina filer. När du har ställt in din filhanterare för att visa dolda filer kan du öppna .git-mappen och se ett antal underkataloger. En av dessa kallas “refs” (visas i bilden nedan) och dess “beger sig” Underkatalogen innehåller listor för alla grenar i ditt projekt. I början har du bara en, dubbad “bemästra.”

Refs-katalogen håller rekord över filialen, men inte filialen själv. Åtminstone, inte filialen du är använder för närvarande. Dessa filer finns i arbetsboken (“~ / Temp / post programmering-git-grenen” i ovanstående exempel) så att du kan komma åt dem på ett normalt sätt. Att göra exakt det, vi skapar vår första fil (namngiven “först-fil.txt”) i arbetskatalogen, dvs. utanför .git-katalogen. Kontrollera detta med hjälp av de tillförlitliga kommandon från föregående intro till gitartikel Hantera din filversionering som en programmerare med Git Hantera din filversionering Som en programmerare med Git Programmerare skapade versionskontrollsystem (VCS) för att lösa filversionskontrollproblem. Låt oss titta på grunderna för versionskontroll med dagens toppsystem, Git. Läs mer :

Vi kan se nu, arbetskatalogen har två filer, den vi åtagit, och en skapad automatiskt av git (den innehåller det förbundsmeddelande vi just angett).

Nu, låt oss skapa en ny git-gren som heter “testning”:

git grenen testning

Checkar ut filialen och arbetar i den

Vi kan utgå ovanstående kommando utan några namn för att få en lista över alla grenar, liksom vilken vi använder för närvarande (dvs vilken är “checkat ut”):

Om vi ​​tittar på katalogstrukturen ser vi nu “.git / ref / huvuden” har nu två filer, en för varje “bemästra” och “testning.”

Var och en av dessa är en förteckning över de fördrag som utgör filialen. Till exempel, om vi undersöker “bemästra” gren med “git logg” kommando, vi kan se en rad för alla de fördrag som gjorts till den grenen.

Processen “checkar ut” en filial innebär att ändringar du gör till filer kommer att ingå i den grenen, men inte andra grenar. Antag att vi kolla in testgit-filialen med följande kommando:

git checkout testning

Sedan lägger vi till en rad text till första filen.txt, givetvis begår den efteråt. Om du växlar tillbaka till huvudkontoret hittar du filen är tom katt kommando visar en fils innehåll i terminalen):

Men återvänder till “testning” filialen har filen fortfarande den tillagda texten:

Men allt vi någonsin ser i katalogen är den enda filen “först-fil.txt.” Var är då dessa två alternativa versioner av samma fil? .Git-katalogen står för dessa ändringar, men inte som du kan förvänta dig.

Hur Git lagrar saker

Om du skulle undersöka ett förråd för andra versionsstyrningssystem som Subversion, skulle du finna att de behåller en kopia per revision för varje enskild fil. Det betyder att om du har ett förråd av en fil, skapa två grenar, innehåller repo två olika kopior av den filen. Faktum är att du faktiskt använder “svn kopia” som kommando att skapa en filial i Subversion! Å andra sidan arbetar git på konceptet av “förändringar.”

Resultatet av ovanstående berättar för oss hela innehållet i “trunk” (SVN: s version av “bemästra”) har kopierats. En titt i en filhanterare bekräftar detta:

De “.git / objekt” katalogen är vad som håller alla dessa små förändringar, och var och en spåras med ett ID. Till exempel, i bilden nedan ser du filer med långa ID-stil namn. Varje liv i en mapp som heter två hexadecimala tecken (8c och 8d Nedan).

Tillsammans utgör dessa mapp- och filnamn ID för en viss förändring (faktiskt en SHA1-hash). Du kan utforska innehållet med hjälp av git cat-fil kommando. Baserat på deras modifierade datum kan vi se den ena början “8d” kom först och det visar ingenting. Medan den som börjar “8c” innehåller den textlinje som vi lagt till i filen i “testning” gren.

Takeaway är den git filialer (inklusive standard “bemästra”) är inte separata “mappar” innehåller kopior av filer. Snarare är de listor över ändringar som gjorts i filer över tiden. Detta är effektivare lagringsvis, men resultatet är detsamma. Allt du gör (bryta?) I en git-fil kvarstår tills du sammanfogar det.

Strategier för sammanslagning Tillbaka till huvudgrenen (för att ta bort eller inte ta bort?)

Antag att du hade ett befintligt projekt med ett antal filer, som du sedan förgrenade sig till “testning,” och gjorde lite arbete på den. Nu vill du få de ändras tillbaka i “bemästra” gren. Du kan göra med följande från “bemästra” gren:

git-fusionstestning

Under förutsättning att det inte finns några konflikter, Byta bestående av den nya texten kommer att vara applicerad till “bemästra.” Resultatet är “först-fil.txt” kommer att vara identiska i båda grenarna. Men det var aldrig riktigt alternativt versioner av filen.

Nu kommer frågan, vad ska man göra med filialen? Det finns två gemensamma strategier för hantering av filialer.

1. En är att hålla en git filial som “testning” att leka i (visas ovan). Du försöker några saker ut och om du kan få dem att fungera, går ändringarna tillbaka i “bemästra.” Då kan du avsluta arbetet på den grenen, eller till och med bli av med det helt. Detta betyder din “bemästra” är den mest stabila versionen av koden, för att den bara borde innehålla saker du känner till. Du kan också tänka på detta tillvägagångssätt som att använda “funktionen grenar.” Detta beror på att deras syfte är att förfina en (eller flera) specifika tillägg till koden.
2. Ett annat tillvägagångssätt är att göra allt ditt huvudsakliga arbete i “bemästra” gren som gör att man går längs vägen. När du är nöjd med funktionaliteten skapar du en gren inom den som du gör buggfixning och liknande. Detta resulterar i mer av a “släppgren” (visas nedan), när de slutar med frisättningen. Det betyder också din “bemästra” gren är typiskt den mest instabila versionen av din kod.

Använd vilken metod som är bäst för dig

Det första tillvägagångssättet här är vanligare när man arbetar med git. Dess andra funktioner (specifikt taggar) gör det enkelt att markera en viss ögonblicksbild av koden som “stabil.” Det låter sig också bättre till större, samarbetsprojekt. Men när du arbetar på dina egna personliga projekt, kan du inte använda vilken av dessa som är mest tillfredsställande. Det fantastiska med att använda git är att du fångar alla dina ändringar, så du kan alltid gå tillbaka och hitta något. Och att organisera ditt projekt med git-grenar gör det lite lättare att göra.

Hur närmar du grenar i dina projekt? Användar du dem för att experimentera, skräp dem sedan? Eller representerar de en detaljerad historia av ditt arbete på projektet?

Låt oss veta nedan i kommentarerna om du har några kloka sätt att hantera filialer i dina gitprojekt!