Hur man installerar och använder Git On Linux för nybörjare

Som utvecklare är vi inte främmande för att hantera och spara olika kopior av kod innan vi går med i huvudkoden.

Låt oss diskutera ett bättre och effektivt sätt att hantera olika kodversioner och slå samman dem med huvudkoden efter testning.

Låt oss dyka in:

Introduktion till versionskontrollsystem

Vi har nämnt att Git är ett versionskontrollsystem. Vad exakt är ett versionskontrollsystem och hur fungerar det?

Ett versionskontrollsystem är ett system som gör det möjligt för utvecklare att spåra filändringar. Versionskontrollsystem fungerar genom att skapa samlingar av olika versioner av filer och de ändringar som gjorts i varje version. De låter dig växla mellan olika versioner av filerna sömlöst.

Ett versionskontrollsystem lagrar en samling filändringar på en plats som kallas ett förvar.

I de flesta fall hjälper versionskontrollsystem till att spåra ändringar i källkodsfiler eftersom de innehåller råtext. Men versionskontrollsystem är inte begränsade till textfiler; de kan spåra även förändringar i binär data.

Typer av versionskontrollsystem

Det finns olika typer av versionskontrollsystem. De inkluderar:

• Lokala versionskontrollsystem: Denna typ av versionskontrollsystem fungerar genom att lagra olika versioner av filerna lokalt genom att skapa kopior av filändringarna.
• Centraliserat versionskontrollsystem: Centraliserat versionskontrollsystem innehåller en central server med olika filversioner. Emellertid behåller utvecklaren fortfarande en kopia av filen på sin lokala dator
• Distribuerat versionskontrollsystem: Kontrollsystemet för distribuerad version kräver ingen server. Det innebär dock att varje utvecklare klonar en kopia av huvudförvaret, och du har tillgång till ändringar av alla filer. Populära distribuerade VC-system är Git, Bazaar och Mercurial.

Låt oss komma igång med Git.

Introduktion till Git

Git är ett distribuerat versionskontrollsystem utvecklat av Linus Torvalds, skaparen av Linux-kärnan. Ursprungligen utvecklad för att hjälpa till att utveckla Linux-kärnan, är Git kraftfull och lätt att använda. Den stöder linjär utveckling, vilket gör att fler än en utvecklare kan arbeta på samma projekt samtidigt.

Låt diskutera hur du installerar Git och använder den för att hantera arkiv:

Hur man installerar Git på Linux

Beroende på vilket system du använder kommer Git att installeras som standard. Vissa system kan dock inte ha det installerat. Om så är fallet, använd följande kommandon för att installera det på ditt system.

Debian / Ubuntu

sudo apt-get update && sudo apt-get upgrade -y sudo apt-get install git -y

Arch Linux

Installera Git on Arch:

sudo pacman -S Git

Fedora / RedHat / CentOS

Installera på RHEL-familjen:

sudo yum installera git
sudo dnf installera git

Hur man konfigurerar Git

När du har installerat Git får du tillgång till alla kommandon som du kan använda för att arbeta med lokala och fjärrstyrda arkiv.

Du måste dock konfigurera den för första gången. Vi använder git config för att ställa in olika variabler.

Den första konfigurationen som vi ställer in är användarnamnet och e-postadressen. Använd git config-kommandot som visas för att ställa in användarnamn, e-postadress och standardtextredigerare.

git config - global användare.namn mitt användarnamn git config -global användare.e-post användarnamn @ e-post.com
git config - global kärna.redaktör vim

Du kan visa git-konfigurationerna med kommandot git config -list som:

git config --list
användare.namn = mitt användarnamn
användare.e-post = användarnamn @ e-post.com
kärna.redaktör = vim

 Så här ställer du in förvar

Vi kan inte nämna Git och misslyckas med att nämna termen repo eller repository.

Ett arkiv, vanligtvis kallat repo, samlar in filer och kataloger med sina respektive ändringar spårade av versionskontrollsystemet.

Ändringar i ett arkiv hanteras eller spåras av åtaganden, vilket är enkla ögonblicksbilder av ändringar som tillämpas på en fil eller katalog.

Åtaganden gör att du kan tillämpa ändringarna eller återgå till en specifik ändring i förvaret.

Låt oss nu diskutera hur man skapar ett Git-arkiv.

Antag att du har en projektkatalog som du vill använda som en git repo och spåra ändringar. Du kan initiera det med kommandot:

git init

När du har kört git init-kommandot initialiserar Git katalogen som ett förvar och skapar en .git-katalog som används för att lagra alla konfigurationsfiler.

För att börja spåra ändringar med Git måste du lägga till det med kommandot Git add. Om du till exempel vill lägga till filen startar du om.c

git lägg till omstart.c

För att lägga till alla filer i den katalogen och börja spåra ändringar, använd kommandot:

git add .

Efter att ha lagt till filer är nästa steg att göra ett engagemang. Som tidigare nämnts hjälper commits att spåra ändringarna av filer i ett arkiv.

Med kommandot git commit kan du lägga till meddelandet som anger ändringarna i filerna.

Till exempel skulle ett meddelande för den ursprungliga åtagandet likna:

git commit -m “Initial Commit.”

NOTERA: Att lägga till beskrivande och meningsfulla git-meddelanden hjälper andra användare som använder förvaret att identifiera filändringar.

gitignore

Anta att du har några filer och kataloger som du inte vill inkludera i huvudförvaret. Du kan till exempel ha konfigurationsfiler för den utveckling du använder.

För att uppnå detta måste du använda .gitignore-fil. I .gitignore-fil kan du lägga till alla filer och kataloger som Git inte ska spåra.

Ett exempel på .gitignore-filen ser vanligtvis ut så här:

.DS_Store
nodmoduler /
tmp /
*.logga
*.blixtlås
.aning/
garn.lås paketlås.json
.tmp *

Git Remote Repositories

Git är ett kraftfullt system som sträcker sig utanför lokala förvar. Tjänster som GitHub, Bitbucket och Gitlab erbjuder fjärrförvar där utvecklare kan vara värd och samarbeta i projekt med git repos.

Även om vissa fjärr-git-tjänster är premium - det finns många gratistjänster tillgängliga - de erbjuder fantastiska verktyg och funktioner som pull-förfrågningar och många andra som säkerställer smidig utveckling.

NOTERA: Du kan också bygga en egen värdtjänst. Kontrollera vår Gogs-handledning för att lära dig hur du gör detta.

Låt oss nu titta på olika sätt att arbeta med fjärrförvar.

Kloning av ett fjärrförvar

Ett populärt sätt att arbeta med fjärrförråd är att kopiera alla filer i en fjärranslutning till en lokal repo; en process som kallas kloning.

För att göra detta, använd kommandot git clone följt av förvarets URL som:

git klon https: // github.com / linuxhint / kod.git

I tjänster som Github kan du ladda ner det förvarade förvaret under alternativet Ladda ner.

Om du vill visa status för filerna i arkivet använder du kommandot git status:

git-status

Detta kommando berättar om filerna i förvaret har ändrats.

Uppdatera lokal repo från fjärrkontrollen

Om du har en klonad förvaring kan du få alla ändringar från fjärrförvaret och slå ihop dem till det lokala med kommandot Git fetch:

git hämta

Skapa ett nytt fjärrförvar

För att skapa ett fjärrförvar från kommandoraden använder du kommandot git remote add som:

git remote lägg till new_repo https: // github.com / linuxhint / new_repo.git

Pressar lokal repo till fjärrkontrollen

För att skicka alla ändringar från en lokal förvaring till en fjärrförvaring kan du använda kommandot git push följt av fjärrförvarets URL eller namn. Kontrollera först att du har lagt till filerna, lagt till ett engagemangsmeddelande som:

git add .
git commit -m ”Lade till en ny funktion i avstängningen. “Git push origin https: // github.com / linuxhint / kod.git

Ta bort ett fjärrförvar

Om du vill ta bort ett fjärrlager från kommandoraden använder du kommandot git remote rm som:

git remote rm https: // github.com / linuxhint / new_repo.git

Slutsats

Vi har täckt grunderna för att konfigurera ett Git-versionskontrollsystem och hur man använder det för att arbeta med lokala och fjärrstyrda förvar.

Denna nybörjarvänliga guide är inte alls ett fullfjädrat referensmaterial. Tänk på dokumentationen eftersom det finns många funktioner som inte beskrivs i denna handledning.