Git Tutorial för nybörjare

Mjukvaruutveckling är ett samarbete. Som mjukvaruutvecklare måste du dela ditt arbete med andra. Men att dela kod och samarbeta kan bli komplicerat. Det är svårt att hålla reda på olika förändringar som händer under programvarans livscykel. Så utvecklingsteam litar på versionskontrollverktyg för att hjälpa till med mjukvarusamarbetet. Git är ett av de mest framträdande versionskontrollverktygen i programvaruindustrin.

Dricks: I den här handledningen lär du dig hur du använder de grundläggande i Git. Varje avsnitt avslutas med några frågor. Du kan läsa frågorna innan du börjar läsa avsnittet. Detta hjälper dig att förstå och uppmärksamma de viktiga punkterna.

Ha kul med att lära dig Git!

Git: En kort översikt

Git är ett distribuerat versionskontrollsystem. Den håller reda på alla ändringar du gör i dina filer och mappar. Det gör det lättare att spara ditt pågående arbete. Om det finns ett problem kan du enkelt kontrollera en tidigare version av filen eller mappen. Om det behövs kan du till och med återställa hela kodbasen till en äldre version.

Utvecklingen av Git startade 2005. Linux-kärngruppen brukade behålla sin kod i BitKeeper, ett patenterat distribuerat versionskontrollsystem. BitKeeper drog dock tillbaka sin fria användning av produkten. Så Linus Torvalds, skaparen och huvudutvecklaren av Linux, designade ett nytt distributionskontrollsystem med öppen källkod som skulle uppfylla kraven i Linux-utvecklingsgemenskapen. Och Git föddes.

Som ett distribuerat versionskontrollsystem kräver Git ingen centraliserad myndighet för att hålla reda på koden. Äldre centraliserade versionskontroller som CVS, SVN eller Perforce kräver centrala servrar för att upprätthålla ändringshistoriken. Git kan hålla koll på alla förändringar lokalt och arbeta peer-to-peer. Så det är mer mångsidigt än centraliserade system.

Frågor:

• Varför ska du använda Git?
• Vad är fördelen med distribuerad versionskontroll?

Installerar Git

För Linux-system är det enkelt att installera Git. Om du använder en Debian-baserad distribution som Ubuntu kan du använda apt install:

$ sudo apt installera git-all

För Fedora, RHEL eller CentOS kan du använda:

$ sudo dnf installera git-all

Du kan kontrollera om Git har installerats med följande kommando:

$ git --version

Det ska visa dig versionen av Git du installerade, till exempel:

git version 2.17.0

När du har installerat Git är det dags att ställa in ditt användarnamn och e-post:

$ git config - global användare.namn "ditt användarnamn"
$ git config - global användare.e-post "[email protected]"

Du kan kontrollera om konfigurationerna har ställts in korrekt med följande kommando:

$ git config --list
användare.namn = ditt användarnamn
användare.e-post = ditt användarnamn @ exempel.com

Dricks: Det är viktigt att ställa in användaren.namn och användare.e-post eftersom dessa konfigurationer används för att spåra dina ändringar.

Frågor

• Vad är kommandot för att installera Git på ditt Linux-system?
• Varför ska du ställa in användare.namn och användare.e-postkonfiguration? Hur ställer du in dem?

Förstå Git konceptuellt

För att kunna använda Git måste du först förstå dessa fyra begrepp:

• Arbetsregister
• Staging Area
• Förvar
• Fjärrförvar

Arbetskatalogen, iscenesättningsområdet och förvaret är lokala för din maskin. Fjärrförvaret kan vara vilken annan dator eller server som helst. Låt oss tänka på dessa begrepp som fyra lådor som kan innehålla standard A1-papper.

Antag att du skriver ett dokument för hand på ett A1-papper vid ditt skrivbord. Du förvarar det här dokumentet i den fungerande katalogrutan. I ett visst skede av ditt arbete bestämmer du att du är redo att behålla en kopia av det arbete du redan har gjort. Så du gör en kopia av ditt aktuella papper och lägger det i iscensättningsrutan.

Iscenesättningsboxen är ett tillfälligt område. Om du bestämmer dig för att kassera fotokopian i iscensättningsrutan och uppdatera den med en ny kopia av arbetskatalogdokumentet finns det ingen permanent registrering av det iscensatta dokumentet.

Antag att du är ganska säker på att du vill ha den permanenta registreringen av dokumentet du har i iscensättningsrutan. Sedan gör du en kopia av iscensättningsdokumentet och flyttar det till förvaringsrutan.

När du flyttar den till förvaringsrutan händer två saker:

1. En ögonblicksbild av dokumentet sparas permanent.
2. En loggfilspost görs för att följa ögonblicksbilden.

Loggposten hjälper dig att hitta den aktuella ögonblicksbilden av ditt dokument om du behöver det i framtiden.

Nu, i den lokala förvaringsrutan, har du en ögonblicksbild av ditt arbete och en loggpost. Men det är bara tillgängligt för dig. Så du gör en kopia av ditt lokala förvaringsdokument tillsammans med loggfilen och lägger den i en ruta i företagets leveransrum. Nu kan alla i ditt företag komma och göra en kopia av ditt dokument och ta det till sitt skrivbord. Lådan i leveransrummet skulle vara fjärrförvaret.

Fjärrförvaret är ungefär som att dela ditt dokument med Google Docs eller Dropbox.

Frågor:

• Kan du definiera arbetskatalog, staging, repository och remote repository?
• Kan du rita hur dokument går från ett steg till ett annat?

Ditt första Git-arkiv

När du har installerat Git kan du börja skapa dina egna Git-arkiv. I det här avsnittet ska du initialisera ditt Git-arkiv.

Antag att du arbetar med ett webbutvecklingsprojekt. Låt oss skapa en mapp som heter project_helloworld och byta till katalogen:

$ mkdir project_helloworld
$ cd project_helloworld

Du kan be Git att övervaka den här katalogen med följande kommando:

$ git init

Du bör se en utdata så här:

Initierat tomt Git-arkiv i / Användare / zakh / _work / LearnGIT / git_tutorial /
project_helloworld /.git

Nu spåras alla filer och mappar i project_helloworld av Git.

Frågor:

• Hur initierar du en katalog som ska spåras av Git?

Grundläggande Git-kommandon: status, logga, lägga till och begå

Statuskommandot visar det aktuella tillståndet för din arbetskatalog och loggkommandot visar historiken. Låt oss prova statuskommandot:

$ git-status
På filialmästaren
Initialt åtagande
inget att begå (skapa / kopiera filer och använd "git add" för att spåra)

Utdata från git-statuskommandot säger att du är på huvudgrenen. Detta är standardgrenen som Git initialiserar. (Du kan skapa egna filialer. Mer om filialer senare). Dessutom säger produktionen att det inte finns något att begå.

Låt oss prova loggkommandot:

$ git-logg
dödlig: din nuvarande filialmästare har inga förbindelser än

Så det är dags att skapa lite kod. Låt oss skapa en fil som heter index.html:

Hej världen

Du kan använda textredigeraren för att skapa filen. När du har sparat filen, kontrollera status igen:

$ git-status
På filialmästaren
Initialt åtagande
Ospårade filer:
(använd "git add ... "att inkludera i vad som kommer att åtagas)
index.html
ingenting läggs till för att begå men ospårade filer närvarande (använd "git add" för att spåra)

Git säger att du har en fil som heter index.html i din arbetskatalog som inte är spårad.

Låt oss se till att indexeras.html spåras. Du måste använda kommandot add:

$ git add index.html

Alternativt kan du använda.”Alternativ för att lägga till allt i katalogen:

$ git add .

Låt oss nu kontrollera status igen:

$ git-status
På filialmästaren
Initialt åtagande
Ändringar som ska göras:
(använd "git rm - cached ... "för att avbryta scenen)
ny fil: index.html

Det gröna indikerar att indexet.html-filen spåras av Git.

Dricks: Som nämnts i instruktionerna ovan, om du använder kommandot:

$ git rm - cachat index.html

Ditt index.html kommer att återgå till ospårad status. Du måste lägga till den igen för att återställa den till iscensättning.]

Låt oss kontrollera loggen igen:

$ git-logg
dödlig: din nuvarande filialmästare har inga förbindelser än

Så även om Git spårar index.html, det finns inget i Git-arkivet om filen än. Låt oss göra våra förändringar:

$ git commit -m "Åtagandeindex.html "
Produktionen ska se ut så här:
[master (root-commit) f136d22] Begå index.html
1 fil ändrad, 6 infogningar (+)
skapa läge 100644 index.html

Texten inuti citaten efter “-m” är en kommentar som går in i loggfilen. Du kan använda git commit utan “-m”, men då öppnar Git en textredigerare som ber dig skriva kommentarer. Det är lättare att bara lägga kommentarerna direkt på kommandoraden.

Låt oss nu kontrollera vår loggfil:

$ git-logg
begå f136d22040ba81686c9522f4ff94961a68751af7
Författare: Zak H
Datum: må 4 juni 16:53:42 2018 -0700
Begår index.html

Du kan se att det visar ett engagemang. Du har framgångsrikt gjort dina ändringar i ditt lokala arkiv. Om du vill se samma logg på ett kortfattat sätt kan du använda följande kommando:

$ git log - online
f136d22 Åtagandeindex.html

Framåt kommer vi att använda den här formen av loggkommandot eftersom det gör det lättare att förstå vad som händer.

Låt oss börja redigera indexet.html. Öppna indexet.html-fil i en redigerare och ändra "Hello world" -raden till "Hello world! Det är jag!”Och spara det. Om du kontrollerar status igen ser du att Git har märkt att du redigerar filen:

$ git-status
På filialmästaren
Ändringar som inte genomförs för att begå:
(använd "git add ... "för att uppdatera vad som kommer att göras)
(använd "git checkout -- ... "för att kassera ändringar i arbetskatalogen)
modifierad: index.html
inga ändringar har lagts till förpliktelsen (använd "git add" och / eller "git commit -a")

Ändringen finns fortfarande i din arbetskatalog. Du måste trycka på den till iscensättningsområdet. Använd add-kommandot du använde tidigare:

$ git add .

Kontrollera status igen:

$ git-status
På filialmästaren
Ändringar som ska göras:
(använd "git reset HEAD ... "för att avbryta scenen)
modifierad: index.html

Nu är dina ändringar i iscensättningsområdet. Du kan begå det till förvaret för permanent förvaring:

$ git commit -m "Ändrat index.html till ett lyckligare meddelande "
[master 0586662] Ändrat index.html till ett lyckligare meddelande
1 fil ändrad, 1 infogning (+), 1 radering (-)

Du kan kontrollera loggen för dina permanenta ändringar:

$ git log - online
0586662 Ändrat index.html till ett lyckligare meddelande
f136d22 Åtagandeindex.html

I det här avsnittet har du lärt dig att använda status, logga, lägga till och begå kommandon för att hålla reda på dina dokument i Git.

Frågor:

• Vad gör git-status?
• Vad gör git log?
• Vad gör git add?
• Vad gör git commit?

Gå tillbaka till äldre filer med kassan

När du gör en fil i Git skapar den en unik hash för varje engagemang. Du kan använda dessa som identifierare för att återgå till en äldre version.

Låt oss anta att du vill gå tillbaka till din tidigare version av indexet.html. Låt oss först titta på indexet.html i nuvarande skick:

$ kattindex.html

Hej världen! Det är jag!

Du kan se att du har den nyare versionen (“Hello world! Det är jag!”). Låt oss kontrollera loggen:

$ git log - online
0586662 Ändrat index.html till ett lyckligare meddelande
f136d22 Åtagandeindex.html

Hashet för den tidigare versionen var f136d22 (“Hello world”).  Du kan använda kassan för att komma till den versionen:

$ git kassa f136d22
Obs: kolla in 'f136d22'.
Du är i "fristående HEAD" -tillstånd. Du kan titta runt, göra experimentella ändringar
och begå dem, och du kan kassera alla åtaganden du gör i detta tillstånd
utan att påverka några grenar genom att utföra en annan kassa.
Om du vill skapa en ny gren för att behålla de åtaganden du skapar kan du
gör det (nu eller senare) genom att använda -b med kassakommandot igen. Exempel:
git kassan -b
HEAD är nu på f136d22 ... Begår index.html

Om du tittar på innehållet i indexet.html ser du:

$ kattindex.html

Hej världen

Det har bara "Hello world". Så ditt index.html har ändrats till den äldre versionen. Om du kontrollerar status:

$ git-status
HEAD fristående på f136d22
inget att begå, arbetar katalogen ren

Git säger i grund och botten att HEAD inte är vid det senaste åtagandet. Du kan gå tillbaka till det senaste åtagandet genom att kolla in huvudgrenen med följande kommando:

$ git checkout master
Tidigare HEAD-position var f136d22 ... Begår index.html
Bytt till filial "master"

Nu om du kontrollerar status:

$ git-status
På filialmästaren
inget att begå, arbetar katalogen ren

Den röda varningen är borta. Om du kontrollerar ditt index.html, du borde vara tillbaka till den senaste versionen:

$ kattindex.html

Hej världen! Det är jag!

Kassakommandot tar dig till olika stater. Vi lär oss mer om kassan i nästa avsnitt.

Frågor:

• Hur använder du kommandot git checkout för att gå till en äldre version av en fil?
• Hur använder du git checkout för att komma tillbaka till den senaste versionen av filen?

Kassa, förgrening och sammanslagning

Förgrening är en av Gits bästa funktioner. Det hjälper dig att separera ditt arbete och experimentera mer. I andra versionskontrollsystem var förgrening tidskrävande och svårt. Git gjorde förgrening och sammanslagning enklare.

Som du märkte i statuskommandot är du i huvudgrenen när du skapar ett nytt Git-arkiv.

$ git-status
På filialmästaren
inget att begå, arbetar katalogen ren

Antag att du skapar en webbplats för din vän David. Du vill återanvända koden på din egen webbplats. Förgrening är en bra lösning. Låt oss kalla filialen david_website.

Du kan utfärda följande kommando:

$ git filial david_website

Du kan använda följande kommando för att se alla grenar:

$ git gren - lista
david_website
* mästare

Stjärnan (*) bredvid mästaren betyder att du fortfarande är i mästergrenen. Du kan kolla in david_website-grenen med följande kommando:

$ git checkout david_website
Bytt till gren 'david_website'

Nu om du igen kontrollerar grenlistan ser du:

$ git gren - lista
* david_website
bemästra

Så du är på david_website-grenen.

Låt oss ändra index.html från “Hello world! Det är jag!”Till” Hej världen! Det är David!”Och sedan iscensätta och begå det:

$ git add .
$ git commit -m "Ändrad webbplats för David"

Om du kontrollerar loggarna bör du se:

$ git log - online
345c0f4 Ändrad webbplats för David
0586662 Ändrat index.html till ett lyckligare meddelande
f136d22 Åtagandeindex.html

Och din indexfil ska se ut så här:

$ kattindex.html

Hej världen! Det är David!

Låt oss nu kolla in huvudgrenen igen:

$ git checkout master
Bytt till filial "master"

Om du kontrollerar status och logg:

$ git-status
På filialmästaren
inget att begå, arbetar katalogen ren
$ git log - online
0586662 Ändrat index.html till ett lyckligare meddelande
f136d22 Åtagandeindex.html

Lägg märke till att du inte har ditt tredje engagemang i master. Eftersom det åtagandet upprätthålls bara i david_website-grenen.

Det här är vad som hände

Antag att du i detta skede bestämmer att du inte vill fortsätta din webbplats. Du blir bara utvecklare för David. Så du vill slå samman ändringarna i david_website-grenen till mastern. Från huvudgrenen behöver du bara utfärda följande kommandon (statuskommandot används för att kontrollera om du är på rätt plats):

$ git-status
På filialmästaren
inget att begå, arbetar katalogen ren
 
$ git merge david_website
Uppdaterar 0586662… 345c0f4
Snabbspola
index.html | 2 +-
1 fil ändrad, 1 infogning (+), 1 radering (-)

Dricks: Du drar ändringar från david_website till master. Du måste vara på mästaren för att uppnå detta.

Om du nu kontrollerar loggen på mastern ser du att det tredje engagemanget finns där:

$ git log - online
345c0f4 Ändrad webbplats för David
0586662 Ändrat index.html till ett lyckligare meddelande
f136d22 Åtagandeindex.html

Du har slagit samman filialen david_website till master. Och ditt index.html för huvudgren ser identisk ut med david_website gren:

$ kattindex.html

Hej världen! Det är David!

Du kan behålla david_website-grenen:

$ git gren - lista
david_website
* mästare

Eller så kan du radera det:

$ git gren -d david_website
Borttagen filial david_website (var 345c0f4).

Efter radering ska du inte se david_website-grenen längre:

$ git gren - lista
* mästare

Dricks: Om Git inte kan slå samman automatiskt under en sammanslagning kommer det att ge dig sammanfogade konfliktfel. I så fall måste du lösa sammanfogningsproblemen manuellt.

Frågor:

• Varför behöver du förgrening?
• Hur förgrena och slå samman filer och mappar?

Fjärrförvar

Hittills har allt ditt arbete varit lokalt. Du har gjort dina ändringar i ett lokalt arkiv. Men det är dags att dela ditt arbete med världen.

Git remote repository är i grunden en annan kopia av ditt lokala repository som andra kan komma åt. Du kan ställa in en server och göra den till fjärrförvaret. Men de flesta använder GitHub eller Bitbucket för detta ändamål. Du kan skapa offentliga arkiv gratis där som alla kan nå.

Låt oss skapa ett fjärrlager på GitHub.

Först måste du skapa ett GitHub-konto []. När du har ett konto skapar du ett nytt förråd med knappen "Nytt förvar". Använd “project_website” som förvarets namn (du kan välja något annat om du vill).

Du bör se en kodflik med instruktioner som dessa:

... eller skapa ett nytt arkiv på kommandoraden

eko "# project_website" >> LÄS.md
git init
git lägg till README.md
git commit -m "first commit"
git fjärrkontroll lägg till ursprung git @ github.com: ditt användarnamn / projekt_webbplats.git
git push -u origin master

Kopiera följande kommando "git remote add origin" och kör det i din arbetskatalog:

$ git fjärrkontroll lägg till ursprung git @ github.com: ditt användarnamn / projekt_webbplats.git

Obs! I ditt fall bör ditt användarnamn vara det du använde för att skapa ditt GitHub-konto.

I ovanstående kommando instruerade du Git platsen för fjärrförvaret. Kommandot säger till Git att "ursprunget" för din projektkatalog för arbetshälsa kommer att vara "[e-postskyddad]: ditt användarnamn / projekt_webbplats.git ”.

Tryck nu din kod från din huvudfilial till ursprung (fjärrförvar):

$ git push origin master
Räkna objekt: 9, färdiga.
Delta komprimering med upp till 4 trådar.
Komprimeringsföremål: 100% (6/6), klar.
Skrivobjekt: 100% (9/9), 803 byte | 0 byte / s, klar.
Totalt 9 (delta 2), återanvändt 0 (delta 0)
fjärrkontroll: Lösa deltor: 100% (2/2), klar.
Att git @ github.com: ditt användarnamn / projekt_webbplats.git
* [ny gren] master -> master

Om du uppdaterar din webbläsare i GitHub bör du se att indexet.html-filen finns där uppe. Så din kod är offentlig och andra utvecklare kan kolla in och ändra kod i fjärrförvaret.

Som utvecklare kommer du att arbeta med andras kod. Så det är värt att försöka checka ut koden från GitHub.

Låt oss gå till en ny katalog där du inte har något. På höger sida av GitHub-förvaret märker du knappen "Klona eller ladda ner". Om du klickar på den ska den ge dig en SSH-adress. Kör följande kommando med SSH-adressen:

$ git klon git @ github.com: ditt användarnamn / projekt_webbplats.git

Utgången ska se ut så här:

$ git klon git @ github.com: ditt användarnamn / projekt_webbplats.git
Kloning till 'projekt_website' ..
fjärrkontroll: Räkna objekt: 9, klar.
fjärrkontroll: Komprimera objekt: 100% (4/4), klar.
fjärrkontroll: Totalt 9 (delta 2), återanvänt 9 (delta 2), återanvänd förpackning 0
Mottagande objekt: 100% (9/9), klar.
Lösa deltor: 100% (2/2), klar.
Kontrollerar anslutning ... gjort.

Det skapar en projektwebbplats i din rena mapp. Om du går in bör du se indexet.html från ditt projekt_hellvärld.

Så du har uppnått följande:

• Skapade och gjorde ändringar i project_helloworld
• Uppladdade koden till GitHub på projekt_website
• Hämtade koden från GitHub

Låt oss en annan fil från den nya arbetskatalogen project_website:

$ touch ReadMe.md
$ git add .
$ git commit -m "Lade till ReadMe.md "
$ git push origin master

Om du uppdaterar sidan GitHub project_website bör du se ReadMe.md-fil där.

Obs! När du laddar ner kod från GitHub känner arbetskatalogen automatiskt till ursprunget. Du behöver inte definiera det med kommandot "git remote add origin".

Frågor:

• Varför behöver du använda fjärrförråd?
• Hur ställer du in ditt nuvarande lokala förråd för att ansluta till fjärrförvaret?
• Hur klonar du fjärrförråd till din lokala dator?

Slutsats

Du hittar mer information om alla kommandon i Git-dokumenten []. Även om det finns Git UI-verktyg tillgängliga är kommandoraden det bästa sättet att bemästra Git. Det ger dig en starkare grund för ditt utvecklingsarbete.

Ytterligare studier:

• https: // git-scm.com / docs
• https: // git-scm.com / book / sv / v2
• https: // git-scm.com / videor