Tutorial su Git Commit: come tracciare e documentare le modifiche al codice

Git è diventato il sistema di riferimento per gestire le modifiche alle codebase. Uno dei comandi più importanti in Git è git commit, che cattura un'istantanea della cronologia del tuo progetto in un preciso momento.

Capire come usare git commit in modo efficiente è fondamentale per mantenere una cronologia del progetto pulita e organizzata. Scrivere messaggi di commit significativi e seguire le best practice garantisce che il tuo repository resti gestibile, che tu stia lavorando da solo o in un team più ampio. 

Questo tutorial ha l'obiettivo di insegnarti come usare il comando git commit, scrivere messaggi di commit chiari e informativi e adottare le best practice per un controllo versione efficace.

Iniziamo!

Cos'è un Git Commit?

Uno dei mattoni fondamentali del controllo versione in Git è il comando git commit. Un git commit cattura un'istantanea dello stato attuale dei file in staging e la salva nella cronologia del repository. Crea un identificatore univoco per le modifiche e registra metadati essenziali, come autore, timestamp e un messaggio di commit descrittivo: questo assicura che le modifiche possano essere tracciate, comprese e, se necessario, ripristinate. 

Gli sviluppatori possono anche aggiungere un messaggio di commit, che descrive brevemente le modifiche effettuate e fornisce contesto e motivazioni dietro all'aggiornamento.

In sostanza, i commit sono importanti perché permettono agli sviluppatori di:

• Tracciare le modifiche: i commit forniscono un registro chiaro delle modifiche apportate alla codebase nel tempo.
• Collaborare: in un team, i commit aiutano a capire quali modifiche sono state fatte, da chi e perché.
• Tornare a stati precedenti: se emerge un bug o un problema, i commit permettono di riportare il progetto a un punto stabile precedente all'introduzione della modifica problematica.
• Mantenere una cronologia pulita: commit strutturati e frequenti con messaggi significativi rendono più facile gestire progetti grandi e diagnosticare i problemi.

> Se stai iniziando con Git e GitHub, la track GitHub Foundations offre un percorso curato per aiutarti a padroneggiare le basi del controllo versione e dei flussi di lavoro collaborativi.

Sintassi di base di Git Commit

Per usare Git in modo efficace, devi capire la sintassi e la struttura di base dei commit. Questa sezione illustra i componenti principali del processo di commit per assicurare che le modifiche vengano catturate e documentate correttamente.

Comando di base

Il modo più semplice per creare un commit è usando il seguente comando: 

git commit -m “Your commit message” 

Qui, il flag -m ti permette di includere un breve messaggio di commit che descrive le modifiche. È qui che fornisci contesto per riferimento futuro e collaborazione, ad esempio: 

git commit -m “Fix bug in user authentication” 

Questo comando crea il commit e lo associa al messaggio fornito. 

Cosa succede durante un commit

Ecco cosa avviene sotto il cofano quando esegui un commit: 

1. Mettere in staging le modifiche: prima di fare il commit, devi mettere in staging le modifiche usando il comando git add. Questo prepara i file modificati per l'inclusione nel prossimo commit. Puoi mettere in staging singoli file o tutti i file modificati. 

git add file.txt  #Stages one file
git add .  #Stages all files in the current directory

2. Eseguire il commit: una volta che le modifiche sono in staging, il comando git commit prende l'istantanea dei file in staging e la salva nel repository. Nota che l'istantanea rappresenta lo stato corrente dei file in quel momento.
3. Aggiornare il repository: dopo il commit, Git aggiorna la cronologia del progetto per salvare il commit insieme a tutti i precedenti. Ogni commit funge da checkpoint a cui è possibile tornare se necessario.

Scrivere messaggi di commit efficaci

Scrivere messaggi di commit chiari e significativi è essenziale per mantenere una cronologia del progetto pulita e comprensibile. Un messaggio di commit ben scritto funge anche da strumento di comunicazione, aiutando sviluppatori e collaboratori a cogliere rapidamente scopo e contesto di ogni modifica.

Importanza di buoni messaggi di commit

Buoni messaggi di commit agiscono come una mappa. Forniscono intuizioni sulle motivazioni dietro ogni modifica, cosa che diventa preziosa quando si rivede il codice in seguito o si risolvono problemi. Messaggi ben scritti rendono anche più facile tracciare bug, capire l'evoluzione delle funzionalità e navigare nella cronologia del repository. 

Best practice per i messaggi di commit

Per assicurarti che i tuoi messaggi di commit assolvano al loro scopo, segui queste best practice:

1. Sii descrittivo: un messaggio di commit dovrebbe spiegare cosa è stato cambiato e, quando rilevante, perché la modifica è stata apportata. Evita messaggi vaghi o generici come "fix" o "update". Punta invece alla specificità. Ad esempio, “Correggi errore di validazione del form di login” è molto più utile di un semplice “Bug fix”.
2. Usa il tempo presente: i messaggi di commit dovrebbero essere scritti al presente. Danno l'impressione che tu stia descrivendo ciò che il commit fa in quel momento. Per esempio, usa "Aggiungi validazione login" invece di "Aggiunta validazione login".
3. Tieni il messaggio breve e semplice: un messaggio conciso è più leggibile. Il sommario (la prima riga del messaggio di commit) dovrebbe tipicamente essere di 50-72 caratteri; se serve più spiegazione, includi una descrizione più lunga nelle righe successive. Questo approccio assicura che il messaggio sia facilmente visualizzabile con vari strumenti e interfacce Git.
4. Usa elenchi puntati per modifiche dettagliate: se il tuo commit include più modifiche correlate, usa punti elenco nella descrizione estesa per scomporre ciò che è stato fatto. Aiuta a creare una struttura chiara, più facile da seguire.

> Se vuoi andare oltre le basi dei commit, il corso Intermediate Git spiega concetti più avanzati come amend, rebase e gestione della cronologia dei commit in team.

Opzioni avanzate di Git Commit

Il flag -m è un'opzione comune usata nei comandi git commit, ed è sufficiente per l'uso quotidiano. Tuttavia, diverse opzioni avanzate offrono maggiore flessibilità ed efficienza nella gestione delle modifiche. In questa sezione, daremo un'occhiata a queste opzioni. 

Commit senza staging

In molti casi, mettere manualmente in staging i file con git add prima del commit può sembrare superfluo, soprattutto quando devono essere committati tutti i file modificati. Per velocizzare questo processo, Git fornisce il flag -a, che mette in staging tutti i file tracciati e li committa in un solo passaggio. Ciò significa che qualsiasi modifica apportata a file già tracciati è inclusa nel commit senza dover eseguire esplicitamente git add.

Ecco come funziona:

git commit -a -m “Your commit message” 

Modificare un commit

Gli errori capitano. A volte potresti dover modificare un commit appena fatto. L'opzione --amend ti permette di correggere il commit più recente invece di crearne uno nuovo. Puoi aggiornare il messaggio di commit o aggiungere ulteriori file allo stesso commit.

Per esempio, per correggere il messaggio dell'ultimo commit: 

git commit --amend -m "Update commit message"

Oppure, se ti sei dimenticato di mettere in staging un file, aggiungi prima il file, poi modifica il commit:

git add missed-file.txt
git commit --amend

Questo sostituisce di fatto il commit precedente con quello aggiornato. 

Nota che l'amend dovrebbe essere fatto solo su commit che non sono stati condivisi con altri (ad esempio, non pushati su un repository condiviso) per evitare di riscrivere la cronologia su cui altri potrebbero dipendere!

Commit con modifiche e file da un commit specifico

A volte devi correggere o sistemare un problema in un commit precedente senza apportare modifiche non correlate. Git offre l'opzione --fixup, che aiuta a creare un commit di follow-up collegato specificamente a uno precedente. È particolarmente utile quando devi ripulire la cronologia dei commit prima di un merge.

Per esempio, per creare un fixup per un commit specifico:

git commit --fixup <commit-hash>

Questo comando creerà un nuovo commit che intende risolvere i problemi nel commit specificato. 

Successivamente, quando esegui un rebase interattivo, Git può comprimere automaticamente questi commit di fixup con il commit originale a cui fanno riferimento.

> Per flussi di lavoro più avanzati come lo squash dei commit, puoi seguire la nostra guida dettagliata nel tutorial su Git Squash Commits.

Gestire i commit con Git

Man mano che il tuo progetto evolve e la cronologia dei commit cresce, la gestione dei commit diventa un aspetto fondamentale per mantenere un repository organizzato e navigabile. Una gestione efficace dei commit aiuta nel debugging, nella collaborazione e nel mantenere una cronologia pulita e comprensibile. 

Git fornisce strumenti potenti che ti permettono di visualizzare la cronologia dei commit e di rivedere o persino annullare le modifiche quando necessario. Sapere come gestire questi commit può farti risparmiare molto tempo nella risoluzione dei problemi o nel rifinire la cronologia del progetto.

Visualizzare la cronologia dei commit

Un aspetto cruciale della gestione dei commit è comprendere la cronologia del progetto. Il comando git log ti consente di visualizzare una cronologia dettagliata dei tuoi commit. Per contesto, fornisce informazioni su quando sono state apportate le modifiche, da chi e quali messaggi sono stati associati.

Per esempio, ecco il comando base git log:

git log

Questo mostra gli hash dei commit, i nomi degli autori, le date e i messaggi di commit. 

Ma Git ti permette anche di personalizzare l'output del log per esigenze specifiche. Ad esempio, puoi limitare il numero di commit mostrati come segue: 

git log -n 5 # shows the last 5 commits

Per ispezionare le modifiche apportate in ciascun commit, usa il flag -p, che mostra il diff per ogni commit. 

Ecco come appare:

git log -p

Ripristinare o annullare un commit

A volte è necessario tornare indietro o annullare delle modifiche. Un modo sicuro per annullare un commit è usando il git revert comando. Questo crea un nuovo commit che annulla le modifiche introdotte da un commit precedente senza alterare la cronologia.

È particolarmente utile quando hai già condiviso i commit con altri e vuoi mantenere intatta la cronologia.

Per revertare un commit, usa il seguente comando:

git revert <commit-hash>

Questo comando applica l'inverso delle modifiche del commit specificato, annullandole di fatto e mantenendo una cronologia trasparente.

Resettare un commit

In alcuni casi, potresti voler riportare completamente il repository a uno stato precedente, cancellando uno o più commit. Il comando git reset ti consente proprio questo. Tuttavia, resettare un commit modifica la cronologia, quindi va usato con cautela, soprattutto se le modifiche sono già state pushate su un repository condiviso.

Git reset offre tre modalità:

1. Soft reset: sposta il puntatore dei commit a un commit specifico ma mantiene le modifiche nella working directory e nell'area di staging. Utile quando vuoi rifare un commit preservando le modifiche. 

git reset --soft <commit-hash>

2. Mixed reset: sposta il puntatore dei commit a un commit specifico e mantiene le modifiche nella working directory, ma svuota l'area di staging. È la modalità predefinita di reset in Git.

git reset --mixed <commit-hash>

3. Hard reset: sposta il puntatore dei commit a un commit specifico e scarta tutte le modifiche sia nella working directory sia nell'area di staging. In pratica riporta il repository allo stato del commit scelto e elimina qualsiasi modifica successiva.

git reset --hard <commit-hash>

Il comando git reset è uno strumento potente, ma è essenziale comprenderne le implicazioni (soprattutto quando si lavora in un ambiente collaborativo).  

Best practice per fare commit in Git

Un controllo versione efficace richiede più che conoscere i comandi Git: significa anche seguire alcune best practice per mantenere una cronologia del progetto pulita, comprensibile ed efficiente. Queste pratiche non solo aiutano a gestire il tuo lavoro, ma rendono anche più facile per i collaboratori contribuire e rivedere le modifiche.

Fai commit frequentemente, ma mantienili piccoli

Una buona regola è committare presto e spesso, ma mantenere ogni commit piccolo e mirato. Questo approccio assicura che ogni commit rappresenti un'unità di lavoro distinta e logica. 

Committare frequentemente aiuta a suddividere grandi modifiche in parti gestibili, rendendo più facile rivedere, testare e tracciare l'evoluzione del progetto. Committando modifiche più piccole e isolate, riduci anche il rischio di introdurre errori complessi. Se qualcosa va storto, è più semplice isolare e correggere il problema quando i commit sono granulari.

Committa solo modifiche correlate

Ogni commit dovrebbe essere focalizzato su un singolo task o problema. Mischiare modifiche non correlate in un unico commit rende più difficile rivedere e capire l'intento dietro le modifiche. Complica anche il processo di revert o cherry-pick di modifiche specifiche, se necessario.

Per esempio, se stai lavorando su una funzionalità ma noti un bug minore altrove nel codice, è meglio gestirli come due commit separati. Questo consente di capire chiaramente cosa è stato fatto e perché – e assicura anche che ogni commit sia significativo e isolato.

Collabora con gli altri sulla cronologia dei commit

Quando lavori in team, è essenziale allinearti con i collaboratori su come i commit vengono gestiti e presentati. Ciò include concordare un formato coerente per i messaggi di commit e assicurarsi che tutti seguano le best practice. Gli hook di Git, come i pre-commit hook, possono aiutare a far rispettare regole come i formati dei messaggi di commit o l'esecuzione dei test prima di consentire un commit.

La collaborazione è facilitata anche da strumenti che aiutano a gestire e rivedere i commit, come le piattaforme di code review come GitHub o GitLab. Una cronologia dei commit chiara e ben documentata rende più facile per i membri del team comprendere le modifiche, discutere miglioramenti e far avanzare il progetto in modo efficiente.

> Vuoi ripulire i file residui prima di fare commit? Scopri come usare git clean in questo tutorial sulla rimozione dei file non tracciati.

Risoluzione dei problemi comuni con Git Commit

I commit Git a volte possono generare errori o difficoltà che possono rallentare il flusso di lavoro. Capire come risolvere questi problemi comuni è cruciale per mantenere un controllo versione fluido ed evitare problemi più grandi in seguito.

Errori nei messaggi di commit

Un errore comune quando si fanno commit è dimenticare di aggiungere un messaggio o usare per sbaglio un messaggio vago o vuoto. Messaggi di commit chiari e informativi sono essenziali per tenere traccia delle modifiche e permettere ai collaboratori di capire la cronologia di un progetto. Git in genere impedisce di committare senza un messaggio, ma è comunque possibile trascurare la qualità del messaggio stesso.

Soluzione: controlla sempre due volte il tuo messaggio di commit prima di premere invio. Se invii per errore un commit con un messaggio vuoto o poco chiaro, puoi correggerlo usando il comando git commit --amend per modificare il messaggio dell'ultimo commit. 

Conflitti dopo il commit

I conflitti sono inevitabili quando più persone lavorano sullo stesso progetto. Spesso emergono dopo un commit quando stai facendo il merge di branch o un rebase. Un conflitto si verifica quando Git non può risolvere automaticamente le differenze tra due commit, lasciandoti la scelta manuale di quali modifiche mantenere.

I conflitti sono più probabili quando due o più contributori modificano la stessa sezione di codice o quando vengono effettuati grandi refactoring. Anche se possono intimidire, Git offre gli strumenti per risolverli senza perdere dati.

Soluzione: quando si verifica un conflitto, Git contrassegnerà le sezioni in conflitto nei file, e dovrai risolverle manualmente modificando il file per riflettere le modifiche desiderate. Dopo aver apportato le modifiche necessarie, metti in staging il file con git add, quindi completa il merge o il rebase committando le modifiche risolte. Strumenti come l'editor dei conflitti di merge di Git o tool esterni di merge possono aiutarti a risolvere i conflitti in modo più efficiente.

Conclusione

Il comando git commit è un aspetto fondamentale del controllo versione in Git che permette agli sviluppatori di creare istantanee del proprio lavoro che possono essere tracciate, riviste e recuperate nel tempo. I commit fungono da tappe nella cronologia di un progetto, chiarendo quali modifiche sono state apportate, perché erano necessarie e quando sono state implementate.

In questo tutorial, abbiamo coperto la sintassi di base e il processo per creare un commit, dal mettere in staging i file con git add al finalizzare il commit con git commit. Abbiamo discusso l'importanza di scrivere messaggi di commit chiari e concisi, seguendo best practice come mantenerli descrittivi, usare il tempo presente e la brevità. 

Inoltre, abbiamo esplorato opzioni avanzate, come committare senza staging e modificare commit, offrendo flessibilità nella gestione delle modifiche. Abbiamo anche visto come gestire i commit con comandi come git log, revert e reset.

Pronto a esplorare GitHub più a fondo? Il nostro corso GitHub Concepts approfondisce fork, branch, issue e best practice di collaborazione. Se ti stai preparando per un flusso di lavoro reale o un colloquio, il Complete Git Cheat Sheet è un'ottima risorsa da tenere a portata di mano!