Git är en kraftfull versionsspårare som låter utvecklare hålla reda på ändringar i sin källkod. Det är ett flitigt använt verktyg av utvecklare med öppen källkod. Även om det designades för att koordinera programmeringsuppgifter, kan Git spåra vilken uppsättning filer som helst effektivt. Dessutom utvecklades den av Linus Torvaldsmannen bakom Linux-kärnan.
Så om du är en öppen källkodsutvecklare som lägger till funktioner till din programvara över tid eller arbetar med flera kamrater för att utveckla banbrytande företagsprodukter, kan Git vara det perfekta spårningssystemet för ditt jobb. Stanna hos oss för att lära dig några av de grundläggande git-kommandona som avsevärt kommer att förenkla dina utvecklingscykler.
Praktiska Git-kommandon för utvecklare med öppen källkod
Git CLI erbjuder ett stort antal git-kommandon för att göra mjukvaruutvecklingsprocessen enklare för utvecklare. Våra redaktörer har beskrivit några av de mest användbara sådana kommandona för att underlätta för våra läsare. Så fortsätt läsa och upptäck dem i din egen takt.
1. Konfigurera användarprofil
Du kan konfigurera din git-profil med kommandot git config. Det minsta du kan ställa in är användarnamnet och e-postadressen. Git tillåter användare att konfigurera dessa policyer antingen globalt eller på projektbasis. Använd kommandot nedan för att ställa in varje förvars användare och e-postadress.
$ git config user.name "USERNAME" $ git config user.email "[email protected]"
Lägg till –global möjlighet att ställa in dessa policyer globalt.
$ git config --global user.name "USERNAME" $ git config --global user.email "[email protected]"
2. Initiera Git Repositories
Ett git-förråd eller helt enkelt repo är rotkatalogen för dina projekt med öppen källkod. Den innehåller källfiler, underkataloger för objekt, huvuden och taggar. Du kan enkelt initiera en git-repo med följande kommando.
$ git init
Det är ett av de vanligaste git-kommandona du kommer att använda. Du kan nu börja lägga till dina källfiler och mixtra med dem som du vill.
3. Lägg till projektfiler
Att lägga till filer till befintliga projekt är mycket enkelt med git. Du kan enkelt lägga till alla modifierade filer/kataloger till spårningssystemet med hjälp av git add-kommandot. Ta en snabb titt på exemplet nedan för att se hur detta fungerar.
—
$ git add file $ git add *.php
När du utfärdar kommandot git add kommer det att lägga till alla filer till projektindexet från den aktuella arbetskatalogen. Du kan specificera särskilda filer som i det första exemplet. Det andra exemplet kommer att lägga till alla PHP-filer till indexet. Git kommer att markera dem för iscensättning.
4. Verifiera tillagda filer
Du kan verifiera filerna som arrangeras under nästa commit med hjälp av git status-kommandot. Det kommer att visa alla nya filer eller filer som har ändrats.
$ git status
Kör kommandot ovan när du vill se detaljerna. Det kommer att visa en sammanfattad lista över alla filer i den kommande commit.
5. Bekräfta ändringar i arkivet
När du genomför dina ändringar tar git en ögonblicksbild av din kodbas. Det är hur git håller reda på dina ändringar och ger versionskontroll. Du måste använda kommandot git commit för detta.
$ git commit
När du kör kommandot ovan kommer git att be dig att ange viss information, som att lägga till en beskrivning. Det kommer att anropa standard Linux-redigeraren du konfigurerade under din git-installation. Använd kommandot nedan för att undvika denna indiskretion.
$ git commit -m "First Commit"
Så du kan lägga till beskrivningen direkt om du använder -m alternativ.
6. Visa loggarna
Du kan kontrollera loggarna när du vill se ändringarna du har gjort i ditt arkiv. Använd kommandot git log från Linux-terminalen för att göra detta.
$ git log $ git log --file
Det första exemplet kommer att visa generaliserad information om dina git-commits. Använd det andra kommandot för att endast visa ändringar i en specifik fil. Du kan lägga till fler alternativ som –loggstorlek option eller till och med sökning begår med reguljära uttryck.
7. Verifiera projektgrenar
En git-gren representerar en oberoende utvecklingslinje i ditt projekt. Du kan enkelt kontrollera din nuvarande gren med kommandot git branch. Den kommer att visa den aktiva grenen där du utvecklar nya funktioner eller ändrar äldre.
$ git branch
Utdata kommer att markera den aktuella grenen med en asterisk
tecken.
8. Återställ projektgrenar
$ git reset
Du kan enkelt återställa det aktuella arkivet och arbetskatalogen till ett känt tillstånd. Kommandot git reset kommer att justera HEAD-referensen till en specifik commit och kommer att uppdatera indexet för att matcha denna speciella commit.
$ git reset --soft
Använd följande kommando för att utföra en mjuk återställning av din nuvarande gren. Du kan också utföra en hård återställning på liknande sätt. Byt bara ut –mjuk med –hård
$ git reset --hard
alternativ, som visas i exemplet nedan.
9. Lägg till en ny filial
$ git branch new-feature
Genom att lägga till en ny gren kan du arbeta självständigt med nyare funktioner. Du kan enkelt lägga till en gren med kommandot git branch. Lägg till filialnamnet, som visas nedan. Verifiera om tillägget lyckades eller inte genom att utfärda kommandot git branch. Den ska visa den nyskapade grenen som heterny-funktion
. Du kan dock inte lägga till mer än en gren med samma filialnamn. Det kommer att orsaka ett allvarligt fel.
10. Växla mellan grenar
$ git checkout new-feature
Du kan enkelt växla mellan olika grenar av ditt projekt med hjälp av checkout-kommandot. Det är ett av de mest använda git-kommandona under mjukvaruutveckling. Ta en snabb titt på nästa exempel för att se hur detta fungerar.
Detta kommando kommer att meddela dig att grenen har bytts. Du kan också verifiera detta med kommandot git branch som visades tidigare.
11. Ta bort en projektgren När du framgångsrikt utvecklar nya funktioner vill du att de ska läggas till i git master-grenen. När detta är gjort kan du gå och ta bort den grenen helt. De -D
$ git checkout master $ git branch -D new-feature
alternativet för git-kommandot låter oss göra detta mycket enkelt.
Du måste gå ut ur grenen först för att radera den. Annars kommer git att ge ett fel.
12. Kontrollera skillnader mellan åtaganden, träd och filer
$ git diff $ git diff new-feature master
Kommandot git diff låter oss se ändringarna i två flera filer, arbetsträdet och indexträdet, mellan commits och mellan blob-objekt. Det är ett av de mest grundläggande git-kommandon som används för att spåra kodbasändringar.
Det första exemplet visar ändringarna mellan arbetsträdet och indexträdet. Det andra exemplet visar ändringar mellan huvudgrenen och grenen med nya funktioner.
13. Slå samman två grenar
$ git merge fixes new-feature $ git merge -s ours obsolete $ git merge --no-commit main
Du kan enkelt slå samman två olika utvecklingsgrenar med kommandot git merge. Det kommer att kombinera två grenar till en enhetlig gren. Du kan använda kommandot git merge för flera ändamål. Titta på exemplet nedan för att se hur vi kan använda dem. Det första exemplet slår samman två grenar ny-funktion och fixar för att skapa en enda gren. Det andra exemplet slår samman obsol]-grenen till den nuvarande utvecklingsgrenen med hjälp av vår
strategi. Det sista exemplet slår samman huvudgrenen till den aktuella grenen men inaktiverar automatisk commit.
14. Återställ befintliga åtaganden
$ git revert ad9ef37d88ad4gfyg90aa6a23f71e775982f4b $ git revert HEAD~3
Ibland kan du bestämma att några av dina åtaganden inte längre krävs. I sådana fall är det bättre att återställa dessa åtaganden än att modifiera grenen helt och hållet. Git revert-kommandot låter oss göra exakt detta. Det första exemplet kommer att återställa ändringarna som införts av commit-id:tf5ad9ef37d88ad4gfyg90aa6a23f71e775982f4b
. Det andra exemplet återfaller den fjärde sista commit i HEAD och utför en ny commit.
15. Stash Working Directory
$ git stash
Du kan tillfälligt spara det aktuella läget för din arbetskatalog någonstans och komma tillbaka till den senare när du vill. Detta kallas stashing i git-terminologi. Den lagrar helt enkelt statusen för din arbetskatalog och indexet så att du kan arbeta med något nytt.
$ git stash list
Utvecklare använder vanligtvis detta kommando när de hamnar i en rörig situation. Det tillåter dem att lagra det stökiga arbetsflödet och komma tillbaka för att lösa det senare. Använd kommandot stash list för att se din stash lista.
16. Klona ett arkiv
$ git clone <GIT:URL> $ git clone git://example.com/git.git/ test-dir
En av de bästa sakerna med öppen källkod är att du arbetar med andras kod som om den vore din egen. Git gör det enkelt att ladda ner ett befintligt projekt med kommandot git clone. Titta på illustrationen nedan för att se hur detta fungerar i verkligheten. Detta kommer att ladda ner nämnda projekt till test-dir
katalogen i ditt system.
17. Dra Nya uppdateringar
$ git pull
Verkliga projekt utvecklas hela tiden. Anta att du klonade ett repo tidigare från ett fjärrlager. Vad kommer du att göra när utvecklarna uppdaterar nya funktioner för det förvaret? Det är obekvämt att klona samma repo om och om igen till din lokala dator. Git pull-kommandot räddar dig från detta.
Detta kommando kommer att uppdatera den lokala versionen av ditt projekt med eventuella nya ändringar som gjorts av samarbetspartnerna. Kom ihåg att ändra din arbetskatalog till projektkatalogen innan du hämtar de senaste uppdateringarna.
18. Push dina uppdateringar
$ git push
När du har arbetat klart med dina uppdateringar kan du lägga till dem i fjärrförvaret genom att trycka på. Skillnaden mellan git push och git commit är att när du gör några ändringar läggs de till i ditt lokala repo snarare än i fjärrrepo.
Detta kommando kommer att lägga till dina uppdateringar till projektets fjärrlager. Du kommer vanligtvis att använda pull and push för att samarbeta med fjärrutvecklare. Så det är viktigt att du behärskar dem perfekt.
19. Visa fjärrarkiv
$ git remote $ git remote --verbose
Git remote-kommandot låter oss hantera en uppsättning spårade arkiv bekvämt från Linux-terminalen. Du kan använda den för att klona endast vissa utvalda grenar. Det första exemplet visar alla fjärrlager som för närvarande är konfigurerade. Lägger till -mångordig
flaggan visar oss detaljerad information om detta.
20. Anslut till Remote Repositories
$ git remote add origin <server>
Du kan ställa in fjärrlager så att ditt lokala arkiv är anslutet till en fjärrserver. Genom att göra detta kommer du att kunna skicka dina lokala ändringar till fjärrservern direkt. Ta en snabb titt på följande illustration för att se hur detta fungerar i praktiken. Ovanstående kommando kommer att lägga till ‘origin’ som fjärrnamn till servern. Du kan upptäcka serverns URL genom att utforska Källa
underfliken i din GitHub-repo.
21. Lägg till taggar till ditt projekt
$ git tag 1.0.0 <commit-id>
Taggar låter dig markera viktiga händelser i dina projekt med öppen källkod. Utvecklare använder dem ofta för att markera nya återfall eller buggfixar. Ta en närmare titt på git-kommandona nedan för att lära dig hur du lägger till taggar till dina projekt med git.
$ git log
Detta kommando lägger till taggen 1.0.0 till den specifika commit. Du kan ta tag i commit-id med kommandot nedan.
$ git push origin --tags
Skjut taggen till din fjärrrepo genom att använda följande kommando. Du måste ange –taggar
alternativet uttryckligen. Annars kommer taggen bara att läggas till din lokala repo, inte till fjärrrepoen.
22. Hämta fjärrdata
$ git fetch origin
Ett annat vanligt git-kommando som du ofta använder är fetch. Det är mycket användbart av flera skäl. För det första hämtar hämta bara nya data/referenser men slår inte ihop dem med din lokala filial. Så du kan vara säker på att arbetskopian av din lokala repo kommer att förbli säker och sund.
Det är ett utmärkt sätt att kontrollera de senaste framstegen för en fjärrkodbas utan att förstöra din egen version av projektet. När du är säker på att all ny data är bra att gå, slå helt enkelt ihop dem till dina lokala filialer.
23. Återställ icke engagerade ändringar
$ git restore --staged test.php $ git restore --source=HEAD --staged --worktree test.php
Kommandot git restore tillåter utvecklare att återställa eventuella icke engagerade ändringar i sina projekt. Det här är ändringar som du har gjort i din arbetsversion av projektet eller innehållet i ditt lokala index. Du kan använda det här kommandot för att antingen återställa ändringar i din arbetskopia, göra ändringar i indexet eller göra både och.
Det första kommandot återställer filen test.php i indexet, och det andra kommandot återställer både indexet och den aktuella arbetskatalogen för ditt projekt.
24. Ta bort filer
$ git rm *.php $ git rm -r dir/ $ git rm --cached *.php
Ibland kanske du vill ta bort några filer från ditt arbetsträd eller projektindex helt och hållet. Du kan använda kommandot git rm för att göra detta. Detta kommando kommer dock inte att ta bort de angivna filerna från din arbetskatalog. Använd kommandot Linux rm för att göra det.
Det första kommandot tar bort alla PHP-filer från arbetsträdet och indexet. Det andra kommandot tar bort allt från dir/-katalogen. Det sista kommandot tar bara bort alla PHP-filer från indexet, inte arbetsträdet.
25. Flytta eller byt namn på filer
$ git mv test.py new-test.py
Du kan flytta eller byta namn på filer med git, precis som du skulle göra med Linux mv-kommandot. Det är faktiskt en förkortning för upptagna utvecklare inbyggd direkt i Git.
$ mv test.py new-test.py $ git add new-test.py $ rm test.py
Ovanstående kommando utför helt enkelt följande Linux-operationer.
Så du kan använda git mv-kommandot för att rädda dig själv från att skriva en massa extra Linux-terminalkommandon.
26. Rensa ospårade filer
$ git clean fatal: clean.requireForce defaults to true and neither -i, -n, nor -f given; refusing to clean
Ospårade filer är filer som inte är under git-versionskontrollsystemet. Du kommer att snubbla över sådana filer ganska ofta när du arbetar med storskaliga projekt. Du kan ta bort dem med flera metoder, inklusive git-återställning och utcheckning. Att använda kommandot git clean är dock det lämpligaste sättet. Ovanstående kommando misslyckades eftersom det är så git är konfigurerat i mitt system. Du kan komma runt problemet genom att lägga till-n ,-jag eller -f
$ git clean -n
alternativ.
27. Optimera lokala förråd
$ git gc
Ett av mina favorit git-kommandon är gc. Den används för sophämtning och hjälper dig att minska storleken på dina lokala repos. Du bör använda det här kommandot ofta om du arbetar med omfattande projekt. Kommandot git gc körs extremt snabbt och rensar upp onödiga filer runt ditt lokala arkiv. Det är en av de bästa optimeringsmetoderna på grund av dess snabbhet och effektivitet. Du kan också använda –aggressiv
möjlighet att öka optimeringen. Det kommer dock att ta längre tid att slutföra.
28. Arkivera lokala förråd
$ git archive --output=test --format=tar master
Du kan enkelt arkivera dina lokala repos genom att använda kommandot git archive. Det tillåter utvecklare att lagra sina projekt på ett säkert ställe. Du kan överföra detta arkiv över nätverket eller lagra det i Linux-filsystemet. Ovanstående kommando lagrar repo i en tar-fil med namnet test. Du kan utelämna –formatera
alternativ om du vill. I det här fallet kommer git att försöka härleda arkivformatet från dess namn. Det finns många fler alternativ tillgängliga för detta kommando.
29. Sök efter mönster
$ git grep -iw 'import' master
När du arbetar med stora projekt behöver du ofta leta efter olika saker. Tack och lov låter git grep-kommandot oss söka efter specifika mönster i våra repos och gör utvecklingen mycket enklare. Det fungerar på samma sätt som vanliga Linux grep-kommandon, med några git-specifika funktioner.
$ git grep 'import' $(git rev-list --all)
Detta kommando visar alla rader som innehåller ‘import’ i vår huvudgren. Den söker på ett skiftlägesokänsligt sätt. Följande kommando kommer att söka efter det givna mönstret i alla commits och grenar.
Detta är ett av de bästa git-kommandona att bemästra om du samarbetar i storskaliga projekt.
30. Hantera arbetsträd
$ git worktree list $ git worktree add new-branch $ git worktree remove new-branch $ git worktree prune
Utvecklare kan arbeta med flera arbetsträd i Git. Detta är användbart när du checkar ut mer än en enskild gren av ditt projekt. Kolla in följande git-kommandon för att se hur man hanterar arbetsträd i git.
Du kan visa de aktuella arbetsträden med det första kommandot. Använd det andra kommandot för att lägga till ett nytt “länkat arbetsträd” och det tredje kommandot för att ta bort det trädet. Det sista kommandot låter dig beskära informationen i arbetsträdet.
31. Beskär ospårade objekt
$ git prune --dry-run $ git prune --verbose --progress
Ibland kanske du vill ta bort objekt som inte längre spåras av git. Git tillhandahåller ett enkelt kommando för att göra detta. Kommandot git prune kommer bara att ta bort ospårade objekt från din objektdatabas, inte referenserna i sig.
Det första kommandot tar inte bort något och visar bara objekt som prune skulle ta bort. Det andra kommandot ger utförlig utdata samt en lägesrapport under raderingsperioden. Du kan använda prune-kommandon för att optimera dina repos tillsammans med git gc-kommandot.
32. Packa upp opackade föremål
$ git repack
I git är paket en samling individuellt komprimerade objekt. Git tillämpar delta-komprimering på dessa objekt och lagrar dem i en enda fil. De används för att minska belastningen på ditt Linux-filsystem eller spegelsystem. Kommandot git repack låter användare skapa nya paket som består av objekt som inte sitter i befintliga paket.
Du kan använda det här kommandot tillsammans med git gc och git prune för att optimera dina git-repos.
33. Lista opackade objekt
$ git count-objects
Du bör inte packa om dina föremål ofta om det inte finns för många uppackade föremål. Kommandot git count-objects är en enkel men användbar metod för att se antalet uppackade objekt och hur mycket diskutrymme de förbrukar. Använd kommandot ovan för att avgöra om det är dags för en git-ompackning eller inte. Du kan lägga till –mångordig flagga för att få detaljerad information och –läsbar för människor
flagga för att visa storleken på ett konventionellt sätt.
34. Validera objektdatabasen
$ git fsck
Git utvecklades som ett filsystem i sina tidiga dagar. Den har ett användbart kommando som heter fsck, som fungerar väldigt likt Unix fsck. Du kan använda det här kommandot för att verifiera anslutningen och utföra integritetskontroller för dina objekt.
Om du kör kommandot ovan visas alla skadade objekt som finns i din objektdatabas. Det är ett av de mest användbara git-kommandona för att hitta saknade eller dåliga objekt.
35. Visa ändringar för varje bekräftelse
$ git whatchanged
Kommandot git whatchanged är ett annat av våra favoritunderkommandon för git. Det är ett enkelt men effektivt sätt att se vilka förändringar varje enskild git-commit introducerar för vårt projekt.
Detta git-kommando kommer att visa information med hjälp av commit-loggar och diff-utgång. Sammantaget är det ganska likt kommandot git log i drift.
36. Sammanfatta logginformation
$ git shortlog $ git shortlog --email --summary
Du kan också använda kommandot git shortlog för att visa historik. Huvudtanken bakom detta kommando är att inkludera utdata i utgivningsmeddelanden. Ta en snabb titt på följande kommando för att se hur detta fungerar. Lägger till –e-post alternativet visar e-postmeddelanden för varje författare. De –sammanfattning
alternativet kommer att undertrycka den vanliga utgången och visar bara antalet commits.
37. Hantera konfigurationsalternativ
$ git config --list
Det finns ett stort antal konfigurationsalternativ tillgängliga för git. Du kan använda kommandot git config för att fråga, ställa in eller ersätta olika alternativ. Ändringar kan göras i både specifika repor och den globala konfigurationen.
$ git config --help
Kommandot ovan kommer att lista alla för närvarande inställda konfigurationsalternativ i git. Du kan enkelt lägga till eller ta bort nya alternativ. Följ hjälpsidan för underkommandot config för att lära dig hur du gör dessa uppgifter.
38. Konsultera Git Hjälp
$ git help $ git --help
Hjälpsidan för git eller andra Linux-terminalkommandon ger sammanfattad information om alla tillgängliga alternativ. Det borde vara det första stället att besöka när du har problem med git. Ta en snabb titt på följande kommandon för att lära dig hur du anropar git-hjälpsidan. Så du kan konsultera git-hjälpsidan genom att använda antingen Unix-stilen –hjälp
$ git <command> --help $ git commit --help
alternativet eller hjälpunderkommandot inbyggt i git. Dessutom tillhandahåller git också hjälpsidor för underkommandon.
39. Se manualsidan
$ man git $ man git commit
Mansidan innehåller djupgående information om git-versionskontrollsystemet och alla dess underkommandon. Du kan se den genom att följa syntaxen nedan.
Så du kan också se manualer för enskilda underkommandon som du kan med hjälpsidan.
40. Visa versionsinformation
$ git --version
Du kan använda följande enkla kommando för att se vilken version av git som är installerad på ditt system. Eftersom git har utvecklats till stor del över tiden, finns det betydande skillnader mellan olika git-versioner.
Använd helt enkelt kommandot ovan för att få den specifika versionen av git tillgänglig på din maskin.
Avslutande tankar
Git har befäst sin position som de-facto versionskontrollsystemet tack vare sin praktiska design och mångsidiga funktionsuppsättning. Även om det finns några bra alternativ, som Mercurial och CVS, gör ett stort antal praktiska git-kommandon den mer mångsidig än sina konkurrenter.
Våra redaktörer har ansträngt sig för att beskriva de mest praktiska kommandona åt dig. Förhoppningsvis har du fått de viktiga insikter du letade efter från den här guiden. Ställ gärna frågor till oss om du har tvivel angående ett visst kommando. Tack för att du stannar hos oss under denna långa guide.
