-
1. Kom igång
- 1.1 Om versionshantering
- 1.2 En kort historik av Git
- 1.3 Vad är Git?
- 1.4 Kommandoraden
- 1.5 Installera Git
- 1.6 Använda Git för första gången
- 1.7 Få hjälp
- 1.8 Sammanfattning
-
2. Grunder i Git
- 2.1 Skaffa ett Git-förvar
- 2.2 Spara ändringar till förvaret
- 2.3 Visa historiken
- 2.4 Ångra saker
- 2.5 Jobba med fjärrförvar
- 2.6 Taggning
- 2.7 Git alias
- 2.8 Sammanfattning
-
3. Git förgreningar
- 3.1 Grenar i ett nötskal
- 3.2 Grundläggande förgrening och sammanslagning
- 3.3 Hantera grenar
- 3.4 Arbetsflöde med grenar
- 3.5 Fjärrgrenar
- 3.6 Grenflytt
- 3.7 Sammanfattning
-
4. Git på servern
- 4.1 Protokollen
- 4.2 Skaffa Git på en server
- 4.3 Generera din publika SSH-nyckel
- 4.4 Konvigurera servern
- 4.5 Git Daemonen
- 4.6 Smart HTTP
- 4.7 GitWeb
- 4.8 GitLab
- 4.9 Alternativ tillhandahållna av tredje part
- 4.10 Sammanfattning
-
5. Distribuerade Git
-
6. GitHub
-
7. Git Tools
- 7.1 Revision Selection
- 7.2 Interactive Staging
- 7.3 Stashing and Cleaning
- 7.4 Signing Your Work
- 7.5 Searching
- 7.6 Rewriting History
- 7.7 Reset Demystified
- 7.8 Advanced Merging
- 7.9 Rerere
- 7.10 Debugging with Git
- 7.11 Submodules
- 7.12 Bundling
- 7.13 Replace
- 7.14 Credential Storage
- 7.15 Summary
-
8. Customizing Git
- 8.1 Git Configuration
- 8.2 Git Attributes
- 8.3 Git Hooks
- 8.4 An Example Git-Enforced Policy
- 8.5 Summary
-
9. Git and Other Systems
- 9.1 Git as a Client
- 9.2 Migrating to Git
- 9.3 Summary
-
10. Git Internals
- 10.1 Plumbing and Porcelain
- 10.2 Git Objects
- 10.3 Git References
- 10.4 Packfiles
- 10.5 The Refspec
- 10.6 Transfer Protocols
- 10.7 Maintenance and Data Recovery
- 10.8 Environment Variables
- 10.9 Summary
-
A1. Bilaga A: Git in Other Environments
- A1.1 Graphical Interfaces
- A1.2 Git in Visual Studio
- A1.3 Git in Eclipse
- A1.4 Git in Bash
- A1.5 Git in Zsh
- A1.6 Git in PowerShell
- A1.7 Summary
-
A2. Bilaga B: Embedding Git in your Applications
- A2.1 Command-line Git
- A2.2 Libgit2
- A2.3 JGit
- A2.4 go-git
- A2.5 Dulwich
-
A3. Bilaga C: Git Commands
- A3.1 Setup and Config
- A3.2 Getting and Creating Projects
- A3.3 Basic Snapshotting
- A3.4 Branching and Merging
- A3.5 Sharing and Updating Projects
- A3.6 Inspection and Comparison
- A3.7 Debugging
- A3.8 Patching
- A3.9 Email
- A3.10 External Systems
- A3.11 Administration
- A3.12 Plumbing Commands
2.5 Grunder i Git - Jobba med fjärrförvar
Jobba med fjärrförvar
För att kunna samarbeta i ett Gitprojekt, behöver du veta hur du hanterar dina fjärrförvar. Fjärrförvar är versioner av ditt projekt som finns på Internet eller ett nätverk någonstans. Du kan ha flera, en som normalt är skrivskyddat eller skrivbart endast för dig. Att jobba med andra innebär att hantera dessa fjärrförvar och skicka och hämta data till och från dem när du behöver delge det du producerat. Att hanterara fjärrförvar inbegriper att veta hur du lägger till dem, tar bort sådana som inte längre är giltiga, hantera grenar på fjärrförvaren och definera dem som spårade eller inte, och mycket annat. I detta avsnitt kommer vi att täcka en del av dessa koncepten.
Notera
|
Fjärrförvar kan även vara på din lokala maskin.
Det är fullt möjligt att du kan jobba mot ett “fjärr''förvar som är på samma värdmaskin som du jobbar på. Ordet ``fjärr” betyder nödvändigtvis inte att förvaret finns på nätverket eller Internet, bara att det finns någon annanstans. Att jobba med ett sådant fjärrförvar inbegriper fortfarande samma sätt att skicka, hämta och applicara ändringar. |
Visa dina fjärrförvar
För att se vilka fjärrförvar du har konfigurerade kan du köra kommandot git remote
.
Det listar namnen på varje fjärrförvar du har specificerat.
Om du har klonat ditt förvar, borde du åtminstone se origin
— det är standardnamnet som Git ger den server du klonat ditt förvar ifrån:
$ git clone https://github.com/schacon/ticgit
Cloning into 'ticgit'...
remote: Reusing existing pack: 1857, done.
remote: Total 1857 (delta 0), reused 0 (delta 0)
Receiving objects: 100% (1857/1857), 374.35 KiB | 268.00 KiB/s, done.
Resolving deltas: 100% (772/772), done.
Checking connectivity... done.
$ cd ticgit
$ git remote
origin
Du kan också specificera -v
som även visar dig sökvägen som Git har sparat för varje namn som används när du hämtar eller skickar data till eller från fjärrförvaret:
$ git remote -v
origin https://github.com/schacon/ticgit (fetch)
origin https://github.com/schacon/ticgit (push)
Om du har mer än ett fjärrförvar listar kommandot alla. Som exempel kan ett förvar med flera fjärrförvar för att arbeta med flera olika kollaboratörer se ut något i stil med detta.
$ cd grit
$ git remote -v
bakkdoor https://github.com/bakkdoor/grit (fetch)
bakkdoor https://github.com/bakkdoor/grit (push)
cho45 https://github.com/cho45/grit (fetch)
cho45 https://github.com/cho45/grit (push)
defunkt https://github.com/defunkt/grit (fetch)
defunkt https://github.com/defunkt/grit (push)
koke git://github.com/koke/grit.git (fetch)
koke git://github.com/koke/grit.git (push)
origin git@github.com:mojombo/grit.git (fetch)
origin git@github.com:mojombo/grit.git (push)
Detta betyder att vi kan hämta bidrag från vilken som helst av dessa ganska enkelt. Utöver det kanske vi har rättigheter att skicka ändringar till en eller flera av dessa, men det kan vi inte avgöra här.
Notera att dessa fjärrförvar använder varierande protokoll; vi kommer behandla detta mer i Skaffa Git på en server.
Lägga till fjärrförvar
Vi har nämnt och givit lite demonstrationer av hur kommandot git clone
implicit lägger till origin
som fjärrförvar för dig.
Såhär gör du för att manuellt lägga till ett nytt fjärrförvar.
För att lägga till ett nytt fjärrförvar i Git som ett namn som du lätt kan referera till, kör git remote add <namn> <url>
:
$ git remote
origin
$ git remote add pb https://github.com/paulboone/ticgit
$ git remote -v
origin https://github.com/schacon/ticgit (fetch)
origin https://github.com/schacon/ticgit (push)
pb https://github.com/paulboone/ticgit (fetch)
pb https://github.com/paulboone/ticgit (push)
Nu kan du använda namnet pb
på kommandoraden istället för hela sökvägen.
Om du till exempel vill hämta all information som Paul har men som du inte har i ditt lokala förvar, kan du köra git fetch pb
:
$ git fetch pb
remote: Counting objects: 43, done.
remote: Compressing objects: 100% (36/36), done.
remote: Total 43 (delta 10), reused 31 (delta 5)
Unpacking objects: 100% (43/43), done.
From https://github.com/paulboone/ticgit
* [new branch] master -> pb/master
* [new branch] ticgit -> pb/ticgit
Pauls master-gren är nu tillgänglig lokalt som pb/master
— du kan slå samman dessa ändringar in i någon av dina grenar eller du kan checka ut en lokal gren av samma version om du vill inspektera den.
(Vi kommer gå igenom vad grenar är och hur du använder dem i mer detalj i Git förgreningar.)
Hämta och uppdatera från dina fjärrförvar
Som du just såg kan du hämta data från dina fjärrprojekt genom:
$ git fetch <fjärrnamn>
Kommandot går ut till fjärrprojektet och hämtar hem all data från projektet som du ännu inte har. Efter att du gjort detta har du referenser till alla grenar på fjärrförvaret som du kan slå samman med dina ändringar eller inspektera när du helst vill.
Om du klonar ett förvar lägger kommandot automatiskt till det fjärrförvaret under namnet “origin”.
Så git fetch origin
hämtar allt nytt arbete som har blivit skickat till fjärrförvaret sedan du klonade (eller senast hämtade data) från det.
Det är viktigt att att kommandot git fetch
bara laddar ner data till ditt lokala förvar — det slår inte automatiskt ihop det med något av ditt arbete eller ändrar det du just nu jobbar med.
Du måste manuellt införliva ändringarna i ditt arbete när du är redo.
Om du nuvarande gren är inställd på att spåra en fjärrgren (se nästa avsnitt och Git förgreningar för mer information), kan du använda kommandot git pull
för att hämta och därefter slå ihop ändringarna i din aktuella gren.
Detta kan vara enklare eller mer bekvämt arbetssätt för dig; och normalt gör kommandot git clone
att din lokala master-gren spårar motsvarande gren i fjärrförvaret (standardnamnet i fjärrförvaret behöver inte vara master) som du klonade från.
Kommandot git pull
hämtar generellt data från servern du ursprungligen klonade ifrån och försöker automatiskt att slå ihop ändringarna i den du just nu jobbar med.
Skicka till dina fjärrförvar
Näär du har ett projekt som du någon gång vill dela med dig av måste du skicka det uppströms.
Kommandot för detta är simpelt: git push <fjärrnamn> <gren>
.
Om du vill skicka upp din master-gren till din origin
server (igen, kloning ställer normalt in båda dessa namn för dig automatiskt), då kan du köra detta för att skicka dina versioner upp till servern:
$ git push origin master
Kommandot fungerar bara om du klonat från en server dit du har skrivrättigheter och om ingen har skickat ändringar under tiden. Om du och någon annan klonar samtidigt och de skickar upp ändringar före dig kommer din sändning självklart att avvisas. Du måste då hämta deras arbete färst och inkorporera i dina innan du tillåts skicka upp din version. Se Git förgreningar för mer detaljerad information om hur du skickar till fjärrservrar.
Inspektera ett fjärrförvar
Om du vill se mer information om en specifikt fjärrförvar, kan du använda kommandot git remote show <remote>
.
Om du kör detta kommando med ett specifikt namn, som till exempel origin
får du något i stil med:
$ git remote show origin
* remote origin
Fetch URL: https://github.com/schacon/ticgit
Push URL: https://github.com/schacon/ticgit
HEAD branch: master
Remote branches:
master tracked
dev-branch tracked
Local branch configured for 'git pull':
master merges with remote master
Local ref configured for 'git push':
master pushes to master (up to date)
Det listar sökväg för fjärrförvaret samt information om spårade grenar.
Kommandot säger även till dig att om du är på master-grenen och kör git pull
, kommer den automatiskt slå samman ändringar med master-grenen på ditt fjärrförvar efter att den hämtat alla fjärreferenser.
Den listar också alla fjärreferenser som den har hämtat.
Detta är ett simpelt exempel som du sannerligen kommer att stöta på.
När du använder Git lite mer kommer du att få mer information från git remote show
:
$ git remote show origin
* remote origin
URL: https://github.com/my-org/complex-project
Fetch URL: https://github.com/my-org/complex-project
Push URL: https://github.com/my-org/complex-project
HEAD branch: master
Remote branches:
master tracked
dev-branch tracked
markdown-strip tracked
issue-43 new (next fetch will store in remotes/origin)
issue-45 new (next fetch will store in remotes/origin)
refs/remotes/origin/issue-11 stale (use 'git remote prune' to remove)
Local branches configured for 'git pull':
dev-branch merges with remote dev-branch
master merges with remote master
Local refs configured for 'git push':
dev-branch pushes to dev-branch (up to date)
markdown-strip pushes to markdown-strip (up to date)
master pushes to master (up to date)
Kommadot visar också viklen gren som automatiskt skickas om du gör git push
och står i en specifik gren.
Den visar också vilka fjärrgrenar på servern som du inte har, och sådana du har men som blivit borttagna från servern, och flera lokala grenar som du automatiskt kan slå ihop ändringar med sin spårade gren då du kör git pull
.
Byta namn på och ta bort fjärrförvar
Du kan köra git remote rename
för att änbdra ett fjärförvars namn.
Om du till exempel vill byta namn på pb
till paul
kan du göra det med git remote rename
:
$ git remote rename pb paul
$ git remote
origin
paul
Det skall tilläggas att detta ändrar alla dina spårade grennamn också.
Det du tidigare refererade till pb/master
är nu paul/master
.
Om du vill ta bort ett fjärrförvar av någon anledning — du har flyttat servern eller använder inte längre en specifik server, eller så kanske en tidigare medarbetare slutat — så kan du antingen använda git remote remove
eller git remote rm
:
$ git remote remove paul
$ git remote
origin
När du väl tagit bort en referens på detta sättet kommer alla spårade grenar och konfigurationsinställningar som associerades med det fjärrförvaret också att tas bort.