Controllo Versione

In qualsiasi attività che preveda la creazione di qualcosa, esiste la possibilità di voler apportare delle modifiche al proprio lavoro, solo per poi rendersi conto di aver commesso un errore, senza la possibilità di tornare indietro. Ed è proprio qui che i sistemi di controllo versione vengono in aiuto!

Sistema di Controllo versione

Uno dei primi ostacoli che si incontra durante la crescita professionale in ambito informatico è proprio la gestione del codice e delle sue modifiche.

Immagina di scrivere una funzione e, dopo ore di lavoro, decidi di modificare alcune parti, per poi renderti conto che le nuove modifiche non solo non funzionano, ma non erano nemmeno necessarie. Inoltre, il classico CTRL+Z potrebbe non essere sufficiente per tornare indietro di così tanto.

È in situazioni come questa che l’utilizzo di uno strumento di controllo versione diventa fondamentale.

Un sistema di controllo versione è un software che permette di gestire il codice sorgente. Con un sistema di controllo versione, è possibile:

Avere più versioni dello stesso codice sorgente
Passare da una versione all’altra
Percorrere lo storico delle modifiche e ripristinare il codice a un certo punto del passato

Tra i vari sistemi di controllo versione, probabilmente il più famoso e utilizzato è GIT.

Creato da Linus Torvalds nel 2005, GIT è diventato uno degli strumenti fondamentali per ogni sviluppatore, subito dopo l’IDE.

Installazione di GIT

Per installare GIT, basta visitare questo link e scaricare la versione adatta al tuo sistema operativo.

Principali comandi di GIT

Sebbene GIT sia integrato in quasi tutti i principali IDE, che forniscono interfacce grafiche comode per la gestione del controllo versione, GIT nasce come strumento da utilizzare tramite interfaccia a riga di comando.

Di seguito, alcuni comandi utili per l’utilizzo quotidiano tramite linea di comando:

Configurare il proprio nome: git config –global user.name “NOME”
- Visualizzare il nome impostato: git config –global user.name
Configurare la propria email: git config –global user.email “EMAIL”
- Visualizzare l’email impostata: git config –global user.email
Inizializzare GIT nel percorso corrente: git init
Visualizzare lo stato del repository: git status

Se nel percorso corrente ci sono già dei file, il comando mostrerà un risultato simile a questo:

A questo punto, puoi aggiungere uno o più file al repository:

Aggiungere un file specifico: git add FILE1.EXT FILE2.EXT …
Aggiungere tutti i file presenti nel percorso corrente: git add .

COMMIT

Dopo aver aggiunto i file a Git, è il momento di eseguire un commit, ovvero registrare le modifiche nel repository:

Commit: git commit -m “COMMENTO”
Visualizzare il commit appena eseguito: git log
- Visualizzare il commit su una singola riga: git log –oneline

A questo punto, potrebbe capitare di essersi dimenticati di aggiungere un file. Per rimediare, basta aggiungere il file e lanciare il seguente comando per modificare il commit precedente:

Modifica commit: git commit –amend -a -m “COMMENTO”

BRANCH

Supponiamo di voler implementare una variante del codice, la quale si sviluppa in parallelo rispetto alla versione principale. In questi casi, si utilizzano i branch.

Creazione nuovo branch: git branch “NOME_BRANCH_SENZA_SPAZI”
Visualizzare branche esistenti: git branch

Come già anticipato, è possibile spostarsi da un branch all’altro. Questo processo si chiama “switch” e può essere fatto verso un branch già esistente o creando un nuovo branch al momento dello switch:

Cambio di branch: git switch “NOME_BRANCH”
Creazione di un nuovo branch e switch: git switch -c “NOME_BRANCH”
Rinominare il branch attuale: git branch -m “NUOVO_NOME”
Eliminazione del branch: git branch -d “NOME”
Unire un branch al branch corrente: git merge “NOME_DEL_BRANCH”

Nelle versioni precedenti di Git, si utilizzava il comando checkout al posto di switch, e l’opzione -b al posto di -c.

STASH

Supponiamo ora di avere delle modifiche in corso, ma si presenti la necessità di lavorare su un altro branch. Poiché sarebbe una buona norma non fare commit di codice incompleto e non testato, possiamo salvare il nostro lavoro nello stash per recuperarlo successivamente.

Salvare il lavoro corrente: git stash
Ripristino dallo stash: git stash pop
Lista di stash: git stash list
Ripristino di uno specifico elemento dalla lista di stash: git stash apply stash@{ID}
Rimozione di un elemento dallo stash: git stash drop stash@{ID}
- Eliminazione di tutti gli elementi: git stash clear

RESTORE

Un’altra funzionalità importantissima è quella che permette di ripristinare un file a uno stato specifico, a patto che le modifiche non siano state già committate:

Ripristino di un file allo stato nell’ultimo commit: git restore FILE-NAME.EXT
Ripristino di un file allo stato in cui si trovava ad uno specifico commit: git restore —source CODICE_DEL_BRANCH FILE_NAME.EXT

Se si desidera rimuovere un file dallo stage, si può utilizzare:

git restore —staged NOME_FILE.EXT

RESET & REVERT

Se si desidera eliminare un commit e tutto il lavoro associato, ci sono due opzioni:

Eliminare la commit salvando i file locali: git reset CODICE_DEL_BRANCH
- Eliminare la commit e i file locali: git reset –hard CODICE_DEL_BRANCH
Eliminare il lavoro committato creando una nuova commit: git revert CODICE_DEL_BRANCH

REBASE

È possibile manipolare lo storico dei commit per nascondere, rinominare, unire o eliminare uno o più commit. Va sottolineato che queste operazioni sono estremamente delicate e vanno eseguite solo in casi eccezionali:

Comando base che apre un editor mostrando i commit più recenti: git rebase -i HEAD~x (x equivale al numero di commit che si voliono visualizzare)
- Se non occorre effettuare alcuna modifica (comportamento di default): pick CODICE_COMMIT MESSAGGIO_ORIGINALE
- Se si vuole modificare il messaggio di una commit: reword CODICE_COMMIT NUOVO_MESSAGGIO
- Modifica di una commit: edit CODICE_COMMIT NUOVO_MESSAGGIO ; a questo punto occorrerà procedere con i seguenti comandi prima di continuare con il rebase:
  - git add FILE.EXT FILE.EXT ..
  - git commit –amend
  - git rebase –continue
- Unire un commit con il precedente (il messaggio finale sarà quello della commit precedente): fixup CODICE_COMMIT
- Cancellazione di una commit: drop CODICE_COMMIT

Supponiamo di avere i seguenti commit su cui intervenire:

abcd – Aggiunta autenticazione jwt

efgh – Aggiuno refresh token jwt

ilmn – Aggiunto file README.md

Se ci si rende conto che il terzo commit non era necessario e che nel secondo c’è un errore di battitura nel messaggio, i passi da seguire sono:

Apertura editor dei commit: git rebase -i HEAD~3

pick abcd Aggiunta autenticazione jwt
pick efgh Aggiuno refresh token jwt
pick ilmn Aggiunto file README.md

Dovremo modificare la situazione nel modo seguente:

pick abcd Aggiunta autenticazione jwt
reword efgh Aggiunto refresh token jwt
drop ilmn Aggiunto file README.md

A questo punto, salvando il file, Git richiederà di inserire un nuovo messaggio per il commit modificato. Dopo averlo fatto, il rebase sarà completato.

TAG

Un tag è un’informazione aggiuntiva associata a un commit e viene generalmente utilizzato per identificare una versione particolarmente importante, come una milestone o una versione rilasciata in ambiente di produzione. Esistono due tipi di tag: i tag leggeri e quelli annotati.

Tag leggero: git tag v1.0.0
Tag annotato: git tag -a v1.0.0 -m “MESSAGGIO DEL TAG”

Come per qualsiasi cosa, ovviamente, è possibile avere una lista dei tag esistenti o cancellarne uno o più:

Lista dei tag: git tag
Eliminazione di un tag: git tag -d v1.0.0

I tag vengono poi inviati al repository o singolarmente o tutti in sieme:

Push di un singolo tag: git push origin v1.0.0
Push di tutti i tag disponibili: git push origin –tags

Conclusioni

Quello che abbiamo visto è solo una piccola parte dei comandi e delle opzioni disponibili per Git. Se vuoi approfondire l’argomento, ti consiglio di visitare il sito ufficiale e consultare la documentazione, che puoi trovare qui.

Sistema di Controllo versione

Installazione di GIT