Git-introduktion



2024-11-29 2024-12-01
----------
Rättstavning på merge-branch
Städning i arbetssteg i Merge-konflikt

2024-11-29
----------
Initial version

Detta är övningar för att träna sig i att använda det populära versionshanteringsverktyget Git.

Git är ett distribuerat versionshanteringsverktyg vilket innebär att alla som arbetar med ett repository har hela förändringshistoriken från alla andra.

Git används för bl.a:

I labbarna här kommer vi att arbeta en del from command-line. Det finns GUI-klienter för Git, men för att nöta in begreppen är det bra att skriva dessa flera gånger - vilket vi gör när vi gör labbarna från commandoprompten.

Mot slutet av dessa labbar övergår vi till GUI-klienter för Git.

Inför dessa labbar behöver vissa förutsättningar vara på plats.

Allmänna förutsättningar

Installera git

  1. Gå till https://git-scm.com/downloads och ladda hem git
  2. Ladda hem och installera Git för ditt operativsystem

Skapa ett repository

En versionshanterad katalog kallas ofta för ett repository.

Ofta har man en central kopia av repositoryt, kallad för remote och de som ändrar i filerna har alla lokala versioner av denna.
Efter incheckningar synkar man med det centrala repositoryt så att alla har chansen att få samma filversioner.

I denna övning ska vi få en katalog i ditt lokala filhanteringssystem versionshanterad med Git.

Arbetsgång

  1. Skapa en ny katalog på din dator
  2. Öppna ett terminalfönster och gå till denna katalog
  3. Skriv git init och tryck ENTER
  4. Vad får du för svar?

Lägga till en fil i versionshantering

Ett tomt repository är inte så upphetsande. Vi lägger till en fil och ser till att den versionshanteras - och gör vår första commit av den.

En commit är en incheckning till repositoryt - alltså en beskriven återställningspunkt i versionshanteringen.

Arbetsgång

  1. Skapa en ny textfil i din versionshanterade katalog
  2. Se till att filen innehåller någon text
  3. Kolla status för versionshanteringen med kommandot git status. Den bör visa att det finns en ändring som inte är med i versionshanteringen.
  4. Se till att ändringen kommer med i en framtida commit med hjälp av kommandot git add <filnamn>
  5. Kolla ånyo status (git status). Nu bör filen vara versionshanterad. Den är dock ännu inte incheckad, utan bara med i de ändringar som kommer med vid en incheckning.
  6. Fundera ut en bra incheckningskommentar för en incheckning, för nu är det dags att checka in
  7. Checka in ändringen med hjälp av git commit -m "Skapade initial version av ny root-fil" (eller vad för kommentar du vill lägga)
  8. Prova igen med git status. Vad får du för svar?
  9. Prova kommandot git log. Vad ser du?

Återgå till tidigare checkin

Ibland gör man bort sig i ändringarna och vill backa till ett tidigare läge. De möjliga lägena för Git utgörs av de olika commits som gjorts.

Kommandot för att gå tillbaka i git är git reset.

Arbetsgång

Nu ska vi fejka att vi av misstag råkar ta bort filen du nyss skapade och vill återskapa denna.

  1. Ta bort filen du skapade i förra labben
  2. Kolla så att den är borta
  3. Gör en git status. Den ska visa att du är oincheckade ändringar i form av en borttagen fil.
  4. Nu, för att återställa till förra committen så skriv git reset --hard och tryck ENTER
  5. Dubbelkolla att du har filen tillbaka

Vill man gå tillbaka längre än till senaste checkin får man lägga till det commit-id som syns när man skriver git log.

Då kan det t.ex. se ut så här: git reset --hard c91bfa18007b0c09d9dae892e5baeb4e9794df73.

Branchning

Inbyggt i Git finns ett system för branchning. Det innebär att man kan skapa en separat version av en en katalog för vissa typer av ändringar - som man sedan kan välja om och när man ska ta med i huvud-versionen av filerna.

Denna mekanism kan vara väldigt användbar för t.ex. kodhantering där man utvecklar enskilda funktioner separat från varandra. Då riskerar man inte att störa varandra.

Man kan se repositoryt som ett träd med flera grenar. Man kan hoppa runt och vara på olika grenar av detta träd.

Arbetsgång

  1. I din katalog, skriv git branch och tryck ENTER för att visa nuvarandre grenar av repositoryt
  2. Skapa en ny branch för en ny JSON-file genom att skriva git branch json-introduction
  3. Skriv git branch igen för att lista grenarna. Vilken gren är du på?
  4. Skriv git checkout json-introduction för att skifta till din nya branch
  5. Dubbelkolla med git branch så att du är på rätt branch
  6. Skapa nu en fil med följande innehåll:
    {
        "name": "Linus Torvalds"
    }
  7. Checka in denna förändring (git add ., git commit -m "JSON file added")
  8. Kolla med kommandot git log för att se tidigare incheckningar med deras kommentarer
  9. Gå tillbaka till master branch med git checkout master. Finns JSON-filen med där?

Merge

När man har gjort ändringar i en branch, och kanske gjort några olika commits, så har man förhoppningsvis fått till den nya featuren. Då är det dags att mergea ihop denna feature-branch med huvudkodbasen så att den blir införlivad i branchen master.

När man ska göra en merge så ställer man sig på den mottagande branchen och drar in den branch man vill ha till den.

Arbetsgång

  1. Kolla vilka brancher du har, och vilken som är din aktuella branch, med git branch
  2. Gå tillbaka till branchen master med git checkout master
  3. Dubbelkolla att du är på branch master med git branch
  4. Kolla ifall JSON-filen finns i katalogen nu
  5. Läs in förändringarna från branchen json-introduction till master med kommandot git merge json-introduction
  6. Kolla så att du inte får några fel.
  7. Kolla så att JSON-filen nu finns i katalogen
  8. Kolla status med git status
  9. Kolla commit-historiken med git log och kolla så att din incheckningskommentar från tidigare är med
  10. Kolla vilka brancher du har med git branch. Finns branchen json-introduction kvar?
  11. Städa bort eventuell branch du inte längre behöver med git branch -d json-introduction (-d står för delete)

Merge-konflikt

Ofta är man flera som jobbar i samma repository. Då kan det uppstå konflikter när flera personer pillat i samma fil.

I denna övning ska vi provocera fram en sådan konflikt, och lösa denna.

Arbetsgång

  1. Säkerställ att du står på branch master (git branch och eventuellt git checkout master)
  2. Skapa en ny branch kallad change1 (git branch change1)
  3. Byt ut namnet i filen till ditt eget namn
  4. Checka in filen med dess förändring (git add person.json följt av git commit -m "Changed person in person.json file")
  5. Gå nu tillbaka till branch master (git checkout master)
  6. Ändra i filen person.json och lägg in ett valfritt namn som varken är ditt eller Linus Torvalds
  7. Checka in denna förändring på branch master (git add person.json följt av git commit -m "Changed person name in person.json file")
  8. Dubbelkolla med git status att förändringen är omhändertagen. Nu har vi två olika brancher med olika ändringar på samma namn.
  9. Nu ska vi försöka mergea dessa två brancher, vilket bör trigga en konflikt. Gör detta när du står i master-branchen och dra in ändringarna från branch change1 med git merge change1
  10. Nu får du veta att du har en Merge-konflikt att hantera. Får du några andra ledtrådar?
  11. Lös konflikten och kolla så att du är ikapp med incheckningar

Klona ner ett repository från remote

Det är bra att kunna skapa egna repositoryn, men det vanligaste är kanske att någon annan redan har skapat ett repository där du förväntas pilla i filerna.
För detta så klonar man hem en kopia av repositoryt - och får då även med all förändringshistorik.

Det finns mängder av olika Git-tjänster som kan tillhandahålla en remote. Några av de vanligaste är GitHub, Microsoft Azure DevOps, Bitbucket o.s.v. men det finns många fler.

Arbetsgång

  1. Gå till https://github.com/kejsardamberg/git-kurs-skandia
  2. Välj knappen <> Code
  3. Lägg märke till vilka alternativ som uppenbarar sig
  4. Välj att lägga URL på klippbordet
  5. Skapa en ny lokal katalog som heter source som INTE ligger i samma katalog som du tidigare arbetat i
  6. Gå till denna katalog (använd cd)
  7. Skriv git clone och klistra in URL från tidigare steg innan du trycker ENTER
  8. Vad händer? Vad står det?
  9. Kolla vad som har kommit ner i din filkatalog

Git pull och git push

När flera personer jobbar mot ett gemensamt remote repository så har alla sina egna förändringar lokalt hela tiden. Oavsett hur många checkins du gör lokalt kommer de inte andra personer till gagn innan du knuffar upp dessa till remote.

Innan man pushar upp sina förändringar bör man göra en pull så att man får hem de förändringar som eventuellt finns i remote redan och kan lösa eventuella merge-problem lokalt så att man inte förstör för andra.

Arbetsgång

  1. Lägg till en ny fil med ditt efternamn som filnamn i det repository som du nyss klonat ner.
  2. Checka in denna fil (git add . följt av git commit -m "Min fil tillagd")
  3. Dubbelkolla så att allt ser rätt ut git status
  4. Hämta hem eventuella förändringar från remote repository med git pull
  5. Kolla om du fick hem något
  6. Pusha upp dina förändringar med git push

Git GUI

Det finns stöd för Git i alla möjliga programmeringsmiljöer, som t.ex. Visual Studio Code, IntelliJ, Eclipse och liknande.

I dessa får man viss hjälp med att synka filer och genomföra merge vid filkonflikter.

Med i Git kommer även två inbyggda GUI-applikationer. Vi ska kika lite på dessa.

Arbetsgång

  1. Öppna programmet gitk, antingen från din startmeny eller från din terminal
  2. Vad ser du i detta program? Är detta lättare eller svårare än i terminalen?
  3. Starta nu programmet git-gui
  4. På samma sätt: Vad kan man använda detta program till?
  5. Gå nu till https://git-scm.com/downloads/guis. Här finns en uppsjö Git-GUI-klienter till. Det kan vara bra att veta.

Sluta versionshantera en katalog

Ibland vill man sluta versionshantera en katalog, t.ex. om man vill zippa ihop den och skicka iväg den.

I rooten på den versionshanterade katalogen finns en dold underkatalog som heter .git i den ligger allt som har med Git att göra.

Arbetsgång

  1. Slå på så att du ser dolda filer och kataloger
  2. Gå till din versionshanterade katalog och identifiera katalogen .git
  3. Kolla med kommandot git status så att katalogen är versionshanterad
  4. Kolla med kommandot git log vad du har för incheckningar
  5. Ta bort katalogen .git
  6. Kolla med kommandot git status igen. Nu ska inte längre katalogen vara versionshanterad med git
  7. Nu lägger vi till katalogen under versionshantering igen: Kör kommandot git init i katalogen igen. Dubbelkolla så att katalogen .git finns igen.
  8. Kör kommandot git status för att se status
  9. Kör kommandot git log och notera att vi nu har tappat bort hela historiken.

Bravo! Det var allt som denna introduktion täcker!

Bra jobbat om du orkade ända hit. :)