Git è un sistema di controllo della versione distribuito open source . Ora ci sono molte parole per definire Git.
Lasciatemi scomporre e spiegare la formulazione:
- Sistema di controllo: questo significa fondamentalmente che Git è un tracker di contenuti. Quindi Git può essere utilizzato per archiviare contenuti: viene utilizzato principalmente per memorizzare il codice a causa delle altre funzionalità che fornisce.
- Sistema di controllo della versione : il codice memorizzato in Git continua a cambiare man mano che viene aggiunto altro codice. Inoltre, molti sviluppatori possono aggiungere codice in parallelo. Quindi il sistema di controllo della versione aiuta a gestire questo problema mantenendo una cronologia dei cambiamenti avvenuti. Inoltre, Git fornisce funzionalità come branch e merge, che tratterò più avanti.
- Sistema di controllo della versione distribuito : Git ha un repository remoto che è memorizzato in un server e un repository locale che è memorizzato nel computer di ogni sviluppatore. Ciò significa che il codice non è solo memorizzato in un server centrale, ma la copia completa del codice è presente in tutti i computer degli sviluppatori. Git è un sistema di controllo della versione distribuito poiché il codice è presente nel computer di ogni sviluppatore. Spiegherò il concetto di repository remoti e locali più avanti in questo articolo.
Perché è necessario un sistema di controllo della versione come Git
I progetti di vita reale generalmente hanno più sviluppatori che lavorano in parallelo. Quindi è necessario un sistema di controllo della versione come Git per garantire che non vi siano conflitti di codice tra gli sviluppatori.
Inoltre, i requisiti in tali progetti cambiano spesso. Quindi un sistema di controllo della versione consente agli sviluppatori di ripristinare e tornare a una versione precedente del codice.
Infine, a volte diversi progetti che vengono eseguiti in parallelo coinvolgono la stessa base di codice. In tal caso, il concetto di ramificazione in Git è molto importante.
Cominciamo subito a usare Git
Piuttosto che menzionare tutti i concetti contemporaneamente, spiegherò i concetti di Git attraverso un esempio in modo che sia più facile da seguire.
Scarica git
Questo collegamento contiene i dettagli su come installare Git in più sistemi operativi:
//git-scm.com/book/en/v2/Getting-Started-Installing-Git
Verifica se Git è installato utilizzando il seguente comando nel prompt dei comandi:
git --version
Crea il tuo repository Git locale
Nel tuo computer, crea una cartella per il tuo progetto. Chiamiamo la cartella del progetto simple-git-demo
.
Vai nella cartella del tuo progetto e aggiungi un repository Git locale al progetto utilizzando i seguenti comandi:
cd simple-git-demo git init
Il git init
comando aggiunge un repository Git locale al progetto.
Aggiungiamo ora un po 'di codice piccolo
Crea un file chiamato demo.txt
nella cartella del progetto e aggiungi il seguente testo al suo interno:
Initial Content
Qui faremo una demo con solo testo normale invece del codice effettivo, poiché l'obiettivo principale di questo articolo è su Git e non su alcun linguaggio di programmazione specifico.
Messa in scena e commit del codice
Il commit è il processo in cui il codice viene aggiunto al repository locale . Prima di eseguire il commit del codice, deve essere nell'area di staging . L'area di staging è lì per tenere traccia di tutti i file che devono essere salvati.
Qualsiasi file che non viene aggiunto all'area di staging non verrà sottoposto a commit. Questo dà allo sviluppatore il controllo su quali file devono essere salvati.
Messa in scena
Utilizzare il seguente comando per la gestione temporanea del file:
git add demo.txt
Nel caso in cui desideri aggiungere più file puoi utilizzare:
git add file1 file2 file3
Se vuoi aggiungere tutti i file all'interno della cartella del tuo progetto nell'area di staging, usa il seguente comando:
git add .
Usalo con attenzione poiché aggiunge tutti i file e le cartelle nel tuo progetto all'area di staging.
Impegnarsi
Utilizzare il seguente comando per eseguire il commit del file:
git commit -m "Initial Commit"
"Initial Commit" è il messaggio di commit qui. Immettere un messaggio di commit pertinente per indicare quali modifiche al codice sono state apportate in quel particolare commit.
Stato di Git e registro di Git
Ora modifica il file demo.txt
file e aggiungi il seguente snippet:
Initial Content Adding more Content
Stato
Utilizzare git status
per trovare informazioni su quali file vengono modificati e quali file sono presenti nell'area di gestione temporanea: mostra anche altre informazioni, che per ora possiamo ignorare.
Usa il seguente comando per vedere lo stato:
git status
Lo stato mostra che demo.txt
è stato modificato e non è ancora nell'area di staging.
Ora aggiungiamo demo.txt
all'area di staging e eseguiamo il commit utilizzando i seguenti comandi:
git add demo.txt git commit -m "demo.txt file is modified"
Log
Utilizzare git log
per stampare tutti i commit che sono stati eseguiti fino ad ora.
Il comando utilizzato per questo è:
git log
Il registro mostra l'autore di ogni commit, la data del commit e il messaggio di commit.
Rami
Fino ad ora non abbiamo creato alcun ramo in Git. Per impostazione predefinita, i commit di Git vanno nel ramo master .
Cos'è una filiale?
Un ramo non è altro che un puntatore all'ultimo commit nel repository Git. Quindi attualmente il nostro ramo principale è un puntatore al secondo commit “demo.txt file is modified”
.
Perché sono necessari più rami?
Sono necessari più rami per supportare più sviluppi paralleli. Fare riferimento all'immagine sottostante per vedere come funzionano i rami.

Inizialmente, il commit 1 e il commit 2 sono stati eseguiti nel ramo master. Dopo il commit 2, viene creato un nuovo Branch chiamato "Test" e il commit 3 e il commit 4 vengono aggiunti al ramo di test.
Allo stesso tempo, un commit 3 e un commit 4 diversi vengono aggiunti al ramo principale. Qui possiamo vedere che dopo il Commit 2, vengono eseguiti due sviluppi paralleli in 2 rami separati.
Il ramo di test e il ramo principale sono divergenti qui e hanno un codice diverso: il codice del ramo di test può essere unito al ramo principale utilizzando git merge
. Questo verrà trattato in seguito.
Crea un nuovo ramo in locale
Crea un nuovo ramo chiamato test usando il seguente comando:
git branch test
Questo comando crea il test
ramo.
Siamo ancora nel contesto del ramo master. Per passare alla test
filiale. usa il seguente comando:
git checkout test
Adesso siamo in test
filiale.
Puoi elencare tutti i rami in locale usando il seguente comando:
git branch
Fai alcuni impegni nel nuovo ramo
Modificare demo.txt
aggiungendo il seguente snippet:
Initial Content Adding more Content Adding some Content from test Branch
Ora stage e commit utilizzando i seguenti comandi:
git add demo.txt git commit -m "Test Branch Commit"
Questo commit è stato eseguito nel Test Branch e ora Test Branch è davanti a Master Branch di 1 commit, poiché il test branch include anche i 2 commit dal master branch.
È possibile verificare la cronologia dei commit in Test Branch utilizzando:
git log
Fusione
Attualmente, Test Branch è davanti al Master di 1 commit. Diciamo che ora vogliamo che tutto il codice nel Test Branch venga riportato al Master Branch. Qui è dove git merge
è molto utile.
Per unire il codice dal ramo di prova al ramo principale, segui questi passaggi:
Per prima cosa torna al ramo principale:
git checkout master
Quindi esegui il merge
comando:
git merge test
Dopo aver eseguito questi 2 comandi, l'unione dovrebbe avere esito positivo. In questo esempio, non ci sono conflitti.
Ma nei progetti reali, ci saranno conflitti quando viene eseguita un'unione. Risolvere il conflitto è qualcosa che viene fornito con l'esperienza, quindi lavorando di più con Git sarai in grado di imparare a risolvere i conflitti.
Correre git log
ora e noterai che anche il master ha 3 commit.
Il repository Git remoto
Fino ad ora, abbiamo lavorato solo nel repository locale. Ogni sviluppatore lavorerà nel proprio repository locale ma alla fine inserirà il codice in un repository remoto. Una volta che il codice si trova nel repository remoto, altri sviluppatori possono vedere e modificare quel codice.

GitHub
Qui useremo GitHub per il repository remoto.
Vai su //github.com/ e crea un account.
Dopo esserti registrato nella home page di GitHub, fai clic su Avvia un progetto per creare un nuovo repository Git. Assegna un nome al repository e fai clic su "Crea repository"
Dai il nome come git-blog-demo
.
Questo creerà un repository remoto in GitHub e quando apri il repository, si aprirà una pagina come l'immagine seguente:

L'URL del repository è la parte evidenziata //github.com/aditya-sridhar/git-blog-demo.git
Per puntare il tuo repository locale al repository remoto, usa il seguente comando:
git remote add origin [repository url]
Git Push
Per inviare tutto il codice dal repository locale al repository remoto, utilizzare il seguente comando:
git push -u origin master
Questo spinge il codice dal ramo master nel repository locale al ramo master nel repository remoto.
Comandi aggiuntivi
Git Pull
git pull
viene utilizzato per estrarre le ultime modifiche dal repository remoto nel repository locale. Il codice del repository remoto viene aggiornato continuamente da vari sviluppatori, quindi git pull
è necessario:
git pull origin master
Git Clone
git clone
viene utilizzato per clonare un repository remoto esistente nel computer. Il comando per questo è:
git clone [repository url]
congratulazioni
Ora conosci le basi su come usare Git, quindi vai avanti ed esplora di più!
Presto pubblicherò un altro articolo sui concetti leggermente più avanzati di Git. Rimanete sintonizzati!
Circa l'autore
Amo la tecnologia e seguo i progressi della tecnologia. Mi piace anche aiutare gli altri con qualsiasi conoscenza che ho nello spazio tecnologico.
Sentiti libero di connetterti con me sul mio account LinkdIn //www.linkedin.com/in/aditya1811/
Puoi anche seguirmi su twitter //twitter.com/adityasridhar18
Il mio sito web: //adityasridhar.com/
Altri messaggi da me
Come usare Git in modo efficiente