-
1. Kom igång
- 1.1 Om versionshantering
- 1.2 En kort historik om Git
- 1.3 Vad är Git?
- 1.4 Kommandoraden
- 1.5 Installera Git
- 1.6 Första gången med Git
- 1.7 Få hjälp
- 1.8 Sammanfattning
-
2. Grunderna i Git
- 2.1 Att få tag i ett Git‑kodförråd
- 2.2 Spara ändringar i kodförrådet
- 2.3 Visa incheckningshistoriken
- 2.4 Ångra saker
- 2.5 Arbeta med fjärrkodförråd
- 2.6 Att tagga
- 2.7 Git-alias
- 2.8 Sammanfattning
-
3. Git-grenar
- 3.1 Grenar i korthet
- 3.2 Grundläggande gren- och sammanfogningsarbete
- 3.3 Grenhantering
- 3.4 Arbetsflöden med grenar
- 3.5 Fjärrgrenar
- 3.6 Ombasering
- 3.7 Sammanfattning
-
4. Git på servern
- 4.1 Protokollen
- 4.2 Konfigurera Git på en server
- 4.3 Generera din publika SSH-nyckel
- 4.4 Konfigurera servern
- 4.5 Git-demon
- 4.6 Smart HTTP
- 4.7 GitWeb
- 4.8 GitLab
- 4.9 Tredjepartsalternativ
- 4.10 Sammanfattning
-
5. Distribuerat Git
-
6. GitHub
-
7. Git-verktyg
- 7.1 Revisionsurval
- 7.2 Interaktiv köläggning
- 7.3 Lägga undan och städa
- 7.4 Signera ditt arbete
- 7.5 Sökning
- 7.6 Skriva om historik
- 7.7 Nollställning förklarad
- 7.8 Avancerad sammanslagning
- 7.9 Rerere
- 7.10 Felsöka med Git
- 7.11 Undermoduler
- 7.12 Bunta
- 7.13 Ersätt
- 7.14 Lagring av inloggningsuppgifter
- 7.15 Sammanfattning
-
8. Anpassa Git
- 8.1 Git‑konfiguration
- 8.2 Git‑attribut
- 8.3 Git‑krokar
- 8.4 Ett exempel på Git‑upprätthållen policy
- 8.5 Sammanfattning
-
9. Git och andra system
- 9.1 Git som klient
- 9.2 Migrera till Git
- 9.3 Sammanfattning
-
10. Git bakom kulisserna
- 10.1 Lågnivådel och användardel
- 10.2 Git-objekt
- 10.3 Git-referenser
- 10.4 Packfiler
- 10.5 Refspecen
- 10.6 Överföringsprotokoll
- 10.7 Underhåll och dataåterställning
- 10.8 Miljövariabler
- 10.9 Sammanfattning
-
A1. Bilaga A: Git i andra miljöer
- A1.1 Grafiska gränssnitt
- A1.2 Git i Visual Studio
- A1.3 Git i Visual Studio Code
- A1.4 Git i IntelliJ / PyCharm / WebStorm / PhpStorm / RubyMine
- A1.5 Git i Sublime Text
- A1.6 Git i Bash
- A1.7 Git i Zsh
- A1.8 Git i PowerShell
- A1.9 Sammanfattning
-
A2. Bilaga B: Bädda in Git i dina applikationer
- A2.1 Git på kommandoraden
- A2.2 Libgit2
- A2.3 JGit
- A2.4 go-git
- A2.5 Dulwich
-
A3. Bilaga C: Git-kommandon
- A3.1 Uppstart och konfiguration
- A3.2 Skaffa och skapa projekt
- A3.3 Grundläggande ögonblicksbilder
- A3.4 Grening och sammanslagning
- A3.5 Dela och uppdatera projekt
- A3.6 Inspektion och jämförelse
- A3.7 Felsökning
- A3.8 Patchning
- A3.9 E‑post
- A3.10 Externa system
- A3.11 Administration
- A3.12 Lågnivåkommandon
3.4 Git-grenar - Arbetsflöden med grenar
Arbetsflöden med grenar
Nu när du har grunderna i grenarbete och sammanslagning, vad kan eller bör du göra med dem? I det här avsnittet går vi igenom några vanliga arbetsflöden som de lättviktiga grenarna möjliggör, så att du kan avgöra om du vill använda dem i din egen utvecklingscykel.
Långlivade grenar
Eftersom Git använder enkel trevägssammanfogning är det i regel lätt att sammanfoga en gren in i en annan flera gånger under en längre period. Det betyder att du kan ha flera grenar som alltid är öppna och som används för olika steg i utvecklingscykeln; du kan regelbundet sammanfoga ändringar från vissa av dem in i andra.
Många Git-utvecklare använder ett arbetsflöde som bygger på detta, till exempel att bara ha helt stabil kod i sin master-gren – ofta bara kod som har publicerats eller ska publiceras som utgåva.
De har en parallell gren som heter develop eller next som de arbetar i eller använder för att testa stabilitet – den är inte alltid stabil, men när den blir stabil kan den sammanfogas in i master.
Den används för att dra in ämnesgrenar (kortlivade grenar, som din tidigare iss53-gren) när de är klara, så att man kan säkerställa att de klarar tester och inte introducerar fel.
I praktiken pratar vi om pekare som rör sig uppåt i raden av incheckningar du gör. De stabila grenarna ligger längre ner i historiken, och de mest nyskapande grenarna ligger längre upp.
Det är ofta enklare att tänka på dem som arbetsfack, där en uppsättning incheckningar flyttas till ett mer stabilt fack när de är fullt testade.
Du kan fortsätta så genom flera stabilitetsnivåer.
Vissa större projekt har även en gren som heter proposed eller pu (föreslagna uppdateringar) som innehåller grenar som kanske inte är redo för next eller master.
Tanken är att dina grenar ligger på olika stabilitetsnivåer; när de når en mer stabil nivå sammanfogas de in i grenen ovanför.
Återigen: flera långlivade grenar är inte nödvändigt, men det är ofta hjälpsamt i stora eller komplexa projekt.
Ämnesgrenar
Ämnesgrenar är användbara i projekt av alla storlekar. En ämnesgren är en kortlivad gren som du skapar och använder för en enskild funktion eller ett sammanhängande arbete. Det här är något du troligen aldrig gjorde i äldre VCS:er eftersom det var för dyrt att skapa och sammanfoga grenar. Men i Git är det vanligt att skapa, arbeta på, sammanfoga och ta bort grenar flera gånger om dagen.
Du såg det i förra avsnittet med grenarna iss53 och hotfix.
Du gjorde några incheckningar på dem och tog bort dem direkt efter att du sammanfogat dem med huvudgrenen.
Tekniken gör att du kan byta kontext snabbt och helt – eftersom arbetet är isolerat i ett fack där alla ändringar har med just det ämnet att göra, blir det lättare att se vad som har hänt vid till exempel kodgranskning.
Du kan låta ändringarna ligga där i minuter, dagar eller månader och sammanfoga dem när de är redo, oavsett i vilken ordning de skapades eller arbetades på.
Anta följande exempel: du gör lite arbete på master, skapar en gren för ett ärende (iss91), jobbar där ett tag, skapar en ny gren för att prova en annan lösning (iss91v2), går tillbaka till master och jobbar där en stund, och skapar sedan en ny gren för något du inte är säker på (dumbidea).
Historiken kommer att se ut ungefär så här:
Anta nu att du gillar den andra lösningen bäst (iss91v2) och att du visat dumbidea för dina kollegor – och det visar sig vara genialt.
Du kan då kasta den ursprungliga iss91-grenen (och förlora incheckningarna C5 och C6) och sammanfoga de två andra.
Historiken ser då ut så här:
dumbidea och iss91v2
Vi går djupare in i möjliga arbetsflöden för Git i Distribuerat Git, så läs det kapitlet innan du bestämmer vilken grenmodell ditt nästa projekt ska använda.
Det är viktigt att komma ihåg att dessa grenar är helt lokala. När du skapar grenar och sammanfogar dem görs allt lokalt i ditt Git-kodförråd – ingen kommunikation sker med en server.