Impara le basi di Git in meno di 10 minuti

di Gowtham Venkatesan

Sì, il titolo è un clickbait. Non c’è modo di capire le basi della tecnologia git in soli 10 minuti. Ma ci si può avvicinare abbastanza in circa 25 minuti. E questo è lo scopo di questo articolo.

Se volete iniziare a conoscere la tecnologia Git, siete venuti nel posto giusto. Questa è una guida completa per principianti su Git. Ci sono molti client per Git. La tecnologia è la stessa indipendentemente dal client. Ma in questa guida useremo GitHub per capire Git.

Iniziamo!

Che cos’è il controllo di versione?

Il controllo di versione è un sistema che registra le modifiche a un file o a un insieme di file nel tempo in modo da poter richiamare versioni specifiche in seguito. Quindi, idealmente, possiamo mettere qualsiasi file nel computer sul controllo di versione.

Umm… Ok… Ma perché?

Ecco il perché:

Un sistema di controllo di versione (VCS) permette di riportare i file ad uno stato precedente, riportare l’intero progetto ad uno stato precedente, rivedere le modifiche fatte nel tempo, vedere chi ha modificato per ultimo qualcosa che potrebbe causare un problema, chi ha introdotto un problema e quando, e altro ancora. Usare un VCS significa anche che se si rovinano le cose o si perdono i file, generalmente si può recuperare facilmente. E a volte vuoi solo sapere “chi ha scritto questa merda”, e avere accesso a queste informazioni è utile?.

Cos’è Git?

Git è un sistema di controllo delle versioni per tracciare i cambiamenti nei file del computer e coordinare il lavoro su quei file tra più persone. Git è un sistema di controllo di versione distribuito. Quindi Git non si basa necessariamente su un server centrale per memorizzare tutte le versioni dei file di un progetto. Invece, ogni utente “clona” una copia di un repository (una collezione di file) e ha l’intera storia del progetto sul proprio disco rigido. Questo clone ha tutti i metadati dell’originale mentre l’originale stesso è memorizzato su un server auto-ospitato o su un servizio di hosting di terze parti come GitHub.

Git ti aiuta a tenere traccia delle modifiche che fai al tuo codice. È fondamentalmente la scheda della cronologia per il tuo editor di codice (senza modalità incognito?). Se in qualsiasi momento durante la codifica si incontra un errore fatale e non si sa quale sia la causa, si può sempre ritornare allo stato stabile. Quindi è molto utile per il debug. Oppure potete semplicemente vedere quali modifiche avete fatto al vostro codice nel tempo.

Nell’esempio sopra, tutte e tre le carte rappresentano versioni diverse dello stesso file. Possiamo selezionare quale versione del file vogliamo usare in qualsiasi momento. Quindi posso saltare a qualsiasi versione del file nel continuum temporale di git.

Git aiuta anche a sincronizzare il codice tra più persone. Quindi immagina che tu e il tuo amico stiate collaborando su un progetto. Entrambi state lavorando sugli stessi file del progetto. Ora Git prende le modifiche che tu e il tuo amico avete fatto indipendentemente e le fonde in un singolo repository “Master”. Quindi usando Git puoi assicurarti che entrambi stiate lavorando sulla versione più recente del repository. Così non dovete preoccuparvi di spedire i vostri file all’altro e lavorare con un numero ridicolo di copie del file originale. E collaborare a lunga distanza diventa facile come HTML?

Git Workflow:

Prima di iniziare a lavorare con i comandi Git, è necessario che tu capisca cosa rappresenta.

Cos’è un repository?

Un repository a.k.a. repo non è altro che una collezione di codice sorgente.

Ci sono quattro elementi fondamentali nel Git Workflow.

Rubrica di lavoro, area di sosta, repository locale e repository remoto.

Se si considera un file nella Working Directory, può trovarsi in tre possibili stati.

1. Può essere staged. Il che significa che i file con le modifiche aggiornate sono segnati per essere impegnati nel repository locale ma non ancora impegnati.
2. Può essere modificato. Il che significa che i file con le modifiche aggiornate non sono ancora memorizzati nel repository locale.
3. Può essere impegnato. Il che significa che le modifiche apportate al file sono memorizzate in modo sicuro nel repository locale.

• git add è un comando utilizzato per aggiungere un file che si trova nella directory di lavoro all’area di staging.
• git commit è un comando usato per aggiungere tutti i file che sono in fase al repository locale.
• git push è un comando usato per aggiungere tutti i file impegnati nel repository locale al repository remoto. Quindi nel repository remoto, tutti i file e le modifiche saranno visibili a chiunque abbia accesso al repository remoto.
• git fetch è un comando usato per ottenere file dal repository remoto al repository locale ma non nella directory di lavoro.
• git merge è un comando usato per ottenere i file dal repository locale nella directory di lavoro.
• git pull è un comando usato per ottenere i file dal repository remoto direttamente nella directory di lavoro. È equivalente a un git fetch e un git merge .

Ora che sappiamo cos’è Git e le sue terminologie di base, vediamo come possiamo inserire un file sotto git. Lo faremo nel modo giusto e nel modo difficile. Senza alcuna applicazione GUI.

Suppongo che tu abbia già un file che vuoi mettere sotto il controllo di versione. In caso contrario create una cartella di esempio chiamata ‘MuskCult’ e metteteci dentro alcuni file di codice di esempio.

Step 0: Creare un account GitHub. Duh.

Se non ne hai già uno, puoi crearlo qui.

Step 1: Assicurati di avere Git installato sulla tua macchina.

Se sei su un Mac, accendi il terminale e inserisci il seguente comando:

$ git --version

Questo richiederà di aprire un installer se non hai già git. Quindi impostatelo usando il programma di installazione. Se avete già git, vi mostrerà semplicemente quale versione di git avete installato.

Se stai usando Linux(deb), inserisci quanto segue nel terminale:

$ sudo apt install git-all

Se sei su Windows:

$ get a mac

Solo uno scherzo… Rilassati… La quantità di persone che ho fatto scattare… Uff…
Vai a questo link o a questo link per maggiori informazioni su come ottenerlo.

Step 2: Di’ a Git chi sei.

Introduciti. Entra in scena. Seriamente, menziona il tuo nome utente e l’indirizzo email di Git, poiché ogni commit di Git userà queste informazioni per identificarti come autore.

$ git config --global user.name "YOUR_USERNAME" 

$ git config --global user.email "[email protected]"

$ git config --global --list # To check the info you just provided

Step 3: Genera/controlla la tua macchina per chiavi SSH esistenti. (Opzionale)

Perché lo chiedi? Utilizzando il protocollo SSH, è possibile connettersi e autenticarsi a server e servizi remoti. Con le chiavi SSH, puoi connetterti a GitHub senza fornire il tuo nome utente o password ad ogni visita.

Segui questo link per saperne di più su SSH.
Vai qui per controllare se hai una chiave SSH esistente.
Vai qui per generare una chiave SSH.
Vai qui per aggiungere la chiave SSH al tuo account GitHub.
E infine vai qui per provare la connessione.

Se avete impostato SSH, ogni comando git che ha un link lo sostituite con:

Instead of : https://github.com/username/reponame

You use : [email protected]/username/reponame.git

 Note : You can use both ways alternatively

Il protocollo SSH verrà utilizzato in questo tutorial.

Passo 4: Facciamo Git

Crea un nuovo repository su GitHub. Segui questo link.
Ora, individua la cartella che vuoi mettere sotto git nel tuo terminale.

$ cd Desktop/MuskCult

Inizializzare Git:

E per metterlo sotto git, inserire:

$ touch README.md # To create a README file for the repository$ git init # Initiates an empty git repository

Ora vai a modificare il file README.md per fornire informazioni sul repository.

Aggiungi i file alla Staging Area per il commit:

Ora per aggiungere i file al repository git per il commit:

$ git add . # Adds all the files in the local repository and stages them for commit

OR if you want to add a specific file

$ git add README.md # To add a specific file

Prima di fare il commit vediamo quali file sono messi in scena:

$ git status # Lists all new or modified files to be committed

Commetti le modifiche che hai fatto al tuo Git Repo:

Ora per commettere i file che hai aggiunto al tuo git repo:

$ git commit -m "First commit"# The message in the " " is given so that the other users can read the message and see what changes you made

Uncommit Changes you just made to your Git Repo:

Ora supponiamo che tu abbia appena fatto qualche errore nel tuo codice o inserito un file indesiderato all’interno del repository, puoi annullare il commit dei file che hai appena aggiunto usando:

$ git reset HEAD~1# Remove the most recent commit# Commit again!

Aggiungi un’origine remota e Push:

Ora ogni volta che si apportano modifiche ai file e li si salva, non saranno automaticamente aggiornati su GitHub. Tutte le modifiche che abbiamo fatto nel file vengono aggiornate nel repository locale. Ora per aggiornare le modifiche al master:

$ git remote add origin remote_repository_URL# sets the new remote

Il comando git remote ti permette di creare, visualizzare e cancellare le connessioni ad altri repository.

$ git remote -v# List the remote connections you have to other repositories.

Il comando git remote -v elenca gli URL delle connessioni remote che hai ad altri repository.

$ git push -u origin master # pushes changes to origin

Ora il comando git push spinge le modifiche nel tuo repository locale fino al repository remoto che hai specificato come origine.

E ora se andiamo a controllare la pagina del nostro repository su GitHub dovrebbe avere un aspetto simile a questo:

E questo è tutto. Hai appena aggiunto i file al repository che hai appena creato su GitHub.

Vedi le modifiche che hai fatto al tuo file:

Una volta che inizi ad apportare modifiche ai tuoi file e le salvi, il file non corrisponderà all’ultima versione che è stata commessa su git. Per vedere le modifiche che hai appena fatto:

$ git diff # To show the files changes not yet staged

Ritorna all’ultima versione impegnata nel Git Repo:

Ora puoi scegliere di ritornare all’ultima versione commessa inserendo:

$ git checkout .

OR for a specific file

$ git checkout -- <filename>

Visualizza la cronologia dei commit:

Puoi usare il comando git log per vedere la storia dei commit che hai fatto ai tuoi file:

$ git log

Ogni volta che fai dei cambiamenti che vuoi che si riflettano su GitHub, i seguenti sono il flusso più comune di comandi:

$ git add .$ git status # Lists all new or modified files to be committed$ git commit -m "Second commit"$ git push -u origin master

Ora se andiamo a vedere il nostro repo, possiamo identificare se il commit ha avuto successo guardando il messaggio di commit per ogni file.

Step 5: Tutto bene… Ma come faccio a scaricare e lavorare su altri repository su GitHub?

Clonare un Git Repo:

Collocatevi nella directory in cui volete clonare il repo. Copia il link del repository che vuoi e inserisci quanto segue:

$ git clone remote_repository_URL

Sentiti libero di andare avanti e clonare il repo che ho creato sopra usando: https://github.com/Gothamv/MuskCult

Pushing Changes to the Git Repo:

Ora puoi lavorare sui file che vuoi e fare il commit delle modifiche localmente. Se vuoi spingere le modifiche a quel repository devi essere aggiunto come collaboratore per il repository o devi creare qualcosa conosciuto come pull request. Vai a vedere come fare una richiesta di pull qui e dammi una richiesta di pull con il tuo file di codice.

Collaborare:

Immagina che tu e il tuo amico stiate collaborando a un progetto. Entrambi state lavorando sugli stessi file del progetto. Ogni volta che fate delle modifiche e le spingete nel repo master, il vostro amico deve tirare le modifiche che avete spinto nel repo git. Significa che per essere sicuri di lavorare sull’ultima versione del repo git ogni volta che iniziate a lavorare, un comando git pull è la strada da seguire.

Ora sotto c’è un esempio di un progetto a cui io e il mio amico stiamo collaborando:

Quindi per assicurarmi che quei cambiamenti si riflettano sulla mia copia locale del repo:

$ git pull origin master

Ecco altri due utili comandi git:

$ git fetch AND$ git merge

In termini più semplici, git fetch seguito da un git merge equivale a un git pull. Ma allora perché esistono questi?

Quando usi git pull, Git cerca di fare automaticamente il tuo lavoro per te. È sensibile al contesto, quindi Git unirà tutti i commit tirati nel ramo in cui state lavorando. git pull fonde automaticamente i commit senza permetterti di rivederli prima.

Quando git fetch, Git raccoglie qualsiasi commit dal ramo di destinazione che non esiste nel tuo ramo corrente e li memorizza nel tuo repository locale. Tuttavia, non li fonde con il tuo ramo corrente. Questo è particolarmente utile se hai bisogno di mantenere il tuo repository aggiornato, ma stai lavorando a qualcosa che potrebbe rompersi se aggiorni i tuoi file. Per integrare i commit nel tuo ramo master, usa git merge.

Una cosa in più:

.gitignore

Cos’è?

.gitignore dice a git quali file (o modelli) dovrebbe ignorare. Di solito è usato per evitare di commettere file transitori dalla tua directory di lavoro che non sono utili ad altri collaboratori, come prodotti di compilazione, file temporanei creati dagli IDE, ecc.

Così nell’esempio precedente, file come __pycache__, .DS_Store sono usati dal sistema per memorizzare informazioni per un accesso più veloce. Questo non è utile per altri collaboratori. Quindi possiamo dire a git di ignorarli aggiungendo un file .gitignore.

Usa il comando touch per creare il file .gitignore:

$ touch .gitignore

E puoi aggiungere i seguenti modelli per dire a git di ignorare tali file.

/*.cmake/*.DS_Store/.user/buildetc. depending upon the files you want git to untrack

E questo è praticamente tutto per le basi. Restate sintonizzati per la Parte 2 che si concentrerà su Branch, Merge, Stash, Rebase ecc.

Se vi è piaciuto l’articolo, non dimenticate di schiacciare il pulsante Clap e assicuratevi di seguirmi per la Parte 2.

Riferimenti :

Aggiungere un progetto esistente a GitHub usando la linea di comando – Documentazione utente
Mettere il tuo lavoro esistente su GitHub può permetterti di condividere e collaborare in molti modi. Se stai migrando il tuo…help.github.comCome annullare (quasi) tutto con Git
Una delle caratteristiche più utili di qualsiasi sistema di controllo della versione è la capacità di “annullare” i tuoi errori. In Git, “undo”…blog.github.comGit sulla linea di comando – Non aver paura di commettere 0.3 documentazione
Ci sono altri modi di installare Git; puoi anche ottenere un’applicazione grafica di Git, che includerà la linea di comando…dont-be-afraid-to-commit.readthedocs.ioInizia ad usare Git dalla riga di comando | GitLab
Documentazione per GitLab Community Edition, GitLab Enterprise Edition, Omnibus GitLab, e GitLab Runner.docs.gitlab.comQual è la differenza tra ‘git pull’ e ‘git fetch’?
Nota del moderatore: Dato che questa domanda ha già avuto sessantasette risposte (alcune cancellate)…stackoverflow.com