Guide till Git. Versionshantering när den är som bäst.

Stor guide för dig som vill börja använda Git men tycker att det verkar svårt och krångligt. Vi tar det från början, steg för steg med allt från command line till Github

Git på svenska

Detta är en guide till Git på svenska. Alla kommandon i Git är dock förstås på engelska och det kan kännas lite fånigt att böja dessa på svenska. “commita”, “adda”, “brancha” och “pulla(!)” kan låta konstigt och om du hellre vill använda svenska ord så har Githubanvändaren bjorne föreslagit en översättning.

Vad gäller artiklar om Git på svenska så har jag inte hittat mycket förutom ett inlägg på republik.se av @binarypassion med titeln Versionshantering med Git. På engelska finns som vanligt mängder med material. Förhoppningsvis kan denna artikel hjälpa svenska utvecklare att komma igång med Git.

Vad är Git?

Git är ett versionhanteringssytem utvecklat av Linux skapare Linus Torvalds. Git är distribuerat vilket innebär att ett centralt arkiv saknas och att vem som helst kan skapa en egen kopia av ett repository. Git är därför ett bra system att använda om man är flera utvecklare i samma projekt men det är också perfekt för egna projekt som man jobbar själv i.

Distribuerat vs centraliserat

Skillnaderna mellan ett distribuerat och ett centraliserat system är flera men kortfattat är den främsta fördelen med ett distribuerat system att alla utvecklare har en helt komplett version av projektets historia till skillnad från ett centraliserat system där man endast har den senaste versionen på sin egen hårddisk. För en detaljerad jämförelse av Git och Subversion (som är ett populärt centraliserat system) så kan du läsa den här bloggposten av @chacon.

Vad är ett Repository?

Ett Git Repositiry (repo) är en samling filer som hör ihop, vanligen ett projekt. Till exempel så har jag ett privat repo till 13 Pixlar på Github. När du arbetar med Git bör du skapa ett repo för varje enskilt projekt du jobbar i. Du kan sedan enkelt skifta mellan olika repos när du hoppar mellan projekt. Repot existerar på din hårddisk och, om du vill, även på en extern server. Du gör ändringarna i ditt lokala repo och skickar sedan upp dessa till fjärr-repot.

Nog snackat, låt oss kicka igång.

Installera Git

Ladda ner Git för ditt operativsystem på den officiella webbplatsen: http://git-scm.com/downloads. Installera. Öppna sedan en git-bash och kör följande kommando för att tala om för Git vem du är:

$ git config --global user.name "Adam Rehal"
$ git config --global user.email "adam@13pixlar.se"

Det är även denna information som visas i informationen om vem som gjort en viss commit.

Navigera sedan till din projekmapp och initiera Git för projektet:

$ cd sökväg/till/ditt/projekt
$ git init

Du har nu skapat ett Git-repo. Om katalogen redan innehöll dina filer eller om du väljer att kopiera ditt projekt hit nu spelar ingen roll. När du har alla filer som du vill versionshantera i katalogen kontrollerar du Gits status:

$ git status

Git visar dig nu att du befinner dig i huvudgrenen (eng; “master”) av ditt repo (mer om grenar/branches senare) och att du har ett antal filer i katalogen som ännu inte spåras (eng: “tracked”). Innan vi säger åt Git att spåra alla filer i vårt projekt skall vi dock göra en sak.

Ignorera vissa filer

Det är nämligen så att vi kanske inte vill ha med vissa filer i versionshanteringen, t.ex vissa konfigurationsfiler, designdokument, grunt-moduler etc. Vi kan tala om för Git att ignorera vissa filer i vårt repo genom att skapa en fil, .gitignore, i vår projektmapp. Skapa filen och klistra in följande:

# Detta är bara ett exempel. Du väljer själv vilka filer du vill ignorera

# Ignorera följande kataloger
node_modules/
dokument/

# Ignorera följande filer
inloggning_till_server.txt
privat_bild.jpg

Notera att # används som kommentar.

Lägg till alla filer

Det sista vis skall göra är att lägga till alla filer till Gits index i och göra vår första commit. Kör först:

$ git add .

…och sen:

$ git commit -m "Vår första commit"

Nu är vi redo att börja jobba som vanligt i vårt projekt.

Grundläggande Git-kommandon

Här följer en genomgång av de vanligaste och mest grundläggande av Gits kommandon. Givetvis finns det fler kommandon och mer avancerade tillämpningar av dessa.

Status

git status

Status-kommandot visar vilka ändrade filer du har i ditt repo och som ännu inte commitats.

Add/Stage

git add [fil(er)]

Med “add” lägger du till ändrade filer och gör dessa redo att commitas. Du kan lägga till en fil genom att ange filnamnet eller alla ändrade filer genom att ange .. Det fina med “add” är att vi kan välja vilka filer som skall ingå i samma commit.

Commit

git commit -m "ett beskrivande meddelande"

Uppdaterar filerna i ditt repo och skapar en punkt som det går att återställa ifrån.

Push

git push

Trycker upp filerna till ditt fjärr-repo, t.ex till Github.

Pull

git pull

Hämtar hem de senaste ändringarna från fjärr-repot.

Clone

git clone [url]

Klonar/kopierar och skapar en egen arbetskopia av ett existerande repo.

Branch

git branch [namn]

Skapar en ny gren av ditt existerande repo. När du växlar mellan grenar kommer Git att se till att endast den aktuella grenens filer finns i din katalog.

Merge

git merge [namn]

Slår ihop nuvarande gren med namnet du anger.

Rebase

git rebase master

Uppdaterar din branch så att den är i synk med master-branchen. Gör detta ofta om ni är flera utvecklare som commitar till samma repo. Tänk även på att göra en pull innan du kör rebase.

Stash

git stash

Sparar undan dina nuvarande ändringar temporärt. Bra om du snabbt behöver byta branch och inte vill förlora dina ändringar. För att återställa din stash kör du:

git stash pop


Github och remote repositories

Du känner säkert till Github. Github är ett community där du kan hosta din kod. Många projekt med öppen källkod använder Github då det är enkelt att samarbeta och bidra till olika projekt, att skapa egen grenar av andras offentliga projekt eller posta buggar (issues) till projekt man använder. På Github finns tusentals intressanta projekt och det ligger utanför den här guidens scope att Beskriva Github i detalj. Det vi skall göra är att skapa ett konto på Github för att lagra vår kod.

Konto på Github

Bege dig till www.github.com och registrera dig. Ange användarnamn och lösenord och välj vilken plan du vill ha. Ett Githubkonto är gratis att använda så länge du bara har publika repos. Du får ha hur många publika repos du vill. Vill du ha privata repos som endast du och de du väljer kommer åt så kostar det från 7$ för 5 privata repos och uppåt. En billig kostnad för en grymt tjänst. När man jobbar med privata projekt vore det dumt att låta vem som helt komma åt dessa, särskillt om utvecklingen sker på uppdrag av en kund. Jag rekommenderar därför att du väljer en plan på t.ex 10 privata repos, något som kostar ca 85 kr i månaden.

Skapa ett Repository och pusha ditt projekt via Git

När du loggat in på Github med ditt konto kan du skapa ett repo. Klicka på repositories -> new, välj ett namn, om repot skall vara publikt eller privat och om du vill skapa en README-fil. När du skapat ditt repo är det dags att koppla ihop dit lokala repo med ditt repo på Github.

SSH-nycklar

För att kunna pusha till ditt fjärr-repo behöver du se till att bli autentiserad så att Github vet att du har rätt att ladda upp/ner filer. För att göra detta navänder sig Github av SSH-nycklar vilka (grovt förenklat) är en fiil innehållande ett lösenord (nyckel). För att skapa nyckelfilerna kör du följande kommando i terminalen:

$ ssh-keygen -t rsa -C "din@epost.se"

Du får frågan var du vill spara din nyckel (trycker du bara enter sparas nyckeln i din hemkatalog) och får sedan välja ett lösenord för filen. När filen har skapats skall vi ge nyckeln till Github. Gå till mappen där du sparade nyckeln och öppna filen som slutar med .pub. Kopiera innehållet och klistra in på ditt Githubkonto under settings -> SSH-keys.

Du kan nu testa din anslutning genom att köra

$ ssh git@github.com

Om allt gick väl kommerGithub svara att autentieringen lyckades.

Gör kopplingen i Git

För att tala om för Git var vårt fjärr-repo finns kör vi följande kommando:

$ git remote add origin git@github.com:användarnamn/reponamn.git

Givetvis skall du byta ut “användarnamn” och “reponamn” mot dina egna.

För att sedan push vårt lokala repo till Github skriver vi:

$ git push origin master

Vi kan även förenkla genom att ange en default upstream för vårt repo genom att köra:

$ git push --set-upstream origin master

I fortsättningen behöver vi därför endast skriva git push i vårt repo och Git håller kolla på vilket fjärr-repo det är vi vill pusha till.

Skapa ett Githubrepo direkt från temninalen

Man kan även, via Githubs API skapa ett Githubrepo direkt från terminalen och därmed slippa göra detta i webbgränssnittet. Följande kommando skapar ett nytt repo på github (byt ut USER och REPO):

$ curl -u 'USER' https://api.github.com/user/repos -d '{"name":"REPO"}'

För privata repos

$ curl -u 'USER' https://api.github.com/user/repos -d '{"name":"REPO", "private":"true"}'

För att göra det hela ännu smidigare kan vi använda ett script som hjälper oss.

Alternativ till Github

Det finns flera alternativ till Github där du kan hosta dina projekt. Några värda att kolla in är SourceForge, Bitbucket och Google Code Hosting som alla erbjuder hosting av Git-repon.

Arbetsflöde med Git

Ett typiskt arbetsflöde med Git kan se ut ungefär så här. Du startar ett nytt projekt, kopierar alla resurser du behöver; templates, javascript-bibliotek, etc till din mapp. Du gör din första commit och börjar sedan utvecklingen. När du utvecklar bör du försöka dela upp arbetet i mindre och sammanhängande delar. Du utvecklar en del, t.ex headern, och commitar sedan denna. Det är viktigt att försöka dela upp sina commits i beståndsdelar som hör ihop och inte göra för stora commits som slår ihop många olika saker. Hellre många mindre commits som är lätta att förstå och göra ogjorda. Tänk även på att skriva ordentliga commit-meddelanden som beskriver vad som är gjort.

Ett exempel

Vi skall precis börja koda en webbsida som vi har skissat upp i Photoshop. Vi har skapat mappen c:/www/webbsida och i mappen har vi tre filer, header.php, content.php och footer.php. Vi öppnar en git-bash och navigerar till mappen:

$ cd c:/www/hemsida

Vi initierar Git i mappen:

$ git init
Initialized empty Git repository in c:/www/hemsida/.git/

Vi lägger till alla filer i Gits index:

$ git add .

…och gör vår första commit:

$ git commit -m "Började utvecklingen"

Det första vi gör är sedan att skapa en stilmall, style.css och lägger in lite generella deklarationer. Sen addar vi och commitar filen

$ git add style.css
$ git commit -m "Skapade style.css"

Vi jobbar sedan med header.php och lägger till HTML-kod, länkar till extern javascript och till vår CSS. Vi  lägger in vår logga och en navigering. Vi lägger även till lite CSS i vår stilmall för att snygga till vår meny.  När vi är nöjda med hur det ser ut så här långt kör vi en status

$ git status
On branch master
Changes not staged for commit:

modified: header.php
modified: style.css

Vi ser här att vi har två modifierade filer som inte är addade. Vi addar filerna och gör en ny commit:

$ git add .
$ git commit -m "Skapade huvudnavigering"

Vi fortsätter sedan att jobba med vår hemsida, uppdaterar content.php och footer.php, skapar en mapp med bilder, och commitar allt eftersom vi gjort färdigt de olika delarna.

Nu är första versionen av vår hemsida färdig och vi vill skicka upp den till vårt fjärr-repo på Github. Efter att ha skapat ett repo på Github lägger vi till en remote:

$ git remote add origin git@github.com:13pixlar/hemsida.git

och pushar sedan våra filer till fjärr-repot:

$ git push origin master

Vi får nu en fantastisk ide till en ny funktion som vi vill lägga till. Vi är inte säkra på att vår idé kommer att funka så vi skapar en ny gren av vårt repo för att göra en prototyp.

$ git branch fantastisk-funktion

Vi har nu två grenar (branches) av vårt repo. Vi växlar till vår nya gren med:

$ git checkout fantastisk-funktion

Sedan kodar vi på vår nya funktionalitet. Vi kan när som helt hoppa till bra till vår master-branch med git checkout master. När vi är färdiga med vår nya funktion och har testat så att den fungerar som den skall bestämmer vi oss för att vi vill ha med den i vår hemsida. Vi slår således ihop vår nya branch med vår master:

$ git checkout master
$ git merge fantastisk-funktion -m "la till ny fantastisk funktion"

och tar sedan bort branchen som inte längre behövs

$ git branch -d fantastisk-funktion

Till sist pushar vi alltihop till vår fjärr-repo:

$ git push origin master

Nöjda med oss själva går vi hem för dagen.

Grafiska gränssnitt för Git

Att använda Gits grundläggande funktioner i terminalen är ganska enkelt. Det kan dock vara skönt att använda ett grafiskt gränssnitt när man jobbar med Git. Grafiska gränssnitt är bra på att visa skillnader i filer och ge en bra överblick över ens aktiva repos. Om du jobbar mot Github kan deras klient vara värd att testa. Denna klient är förenklad och saknar många funktioner men kan vara ett bra första steg för den som precis börjat med Git.

Github for Mac: mac.github.com
Github för Windows: windows.github.com

En lite mer fullfjädrad Git-klient är dock att rekommendera när man blivit varm i kläderna. Det finns många alternativ men min personliga favorit är SourceTree vilken är både lätt att komma igång med och erbjuder fullständig kontroll över dina Git-repos. Dessutom är SourceTree helt gratis och finns till både OSX och Windows.

SourceTree: www.sourcetreeapp.com

Om du kör OSX är det även värt att kolla in GitX och Git Tower där det senare är ett riktigt bra verktyg.

Sammanfattning

I denna artikeln har vi lärt oss vad Git är, hur man installerar det och hur man arbetar med versionshantering i Git. Vi har gått igenom vad Github är och hur det fungerar med remote repos. Slutligen kikade vi lite på några grafiska gränssnitt för Git som kan underlätta arbetsprocessen. Förhoppningsvis har du nu tillräckligt med kött på benen för att börja använda Git redan idag.

Det är värt det.

Vidare läsning och andra resurser

• Github: github.com
• Gits officiella webb: git-scm.com
• Git-tower learn: git-tower.com/learn
• Interatktiv Git-skola: try.github.io
• Git-guide på tuts+: Easy version control with git
• Artikelserie om Git på Smahing Magazine: Modern version control with git series
• SourceTree: www.sourcetreeapp.com
• Github för Windows: windows.github.com

Frågor och feedbak

Har jag missat något, finns det felaktiga uppgifter i artikeln eller undrar du över något? Skriv gärna i kommentarsfältet nedan.