Registro Git avanzato

Lo scopo di qualsiasi sistema di controllo delle versioni è registrare le modifiche al tuo codice. Questo ti dà la possibilità di tornare alla cronologia del tuo progetto per vedere chi ha contribuito a cosa, capire dove sono stati introdotti i bug e annullare le modifiche problematiche. Ma avere tutta questa cronologia disponibile è inutile se non sai come navigare. È qui che entra in gioco il comando git log.

A questo punto, dovresti già conoscere il comando di base git log per la visualizzazione dei commit. Ma puoi modificare questo output passando molti parametri diversi a git log.

Le funzionalità avanzate di git log possono essere suddivise in due categorie: formattazione della modalità di visualizzazione di ogni commit e filtraggio dei commit inclusi nell'output. Insieme, queste due competenze ti danno il potere di tornare al tuo progetto e trovare tutte le informazioni di cui potresti aver bisogno.

Formattazione dell'output del registro

Innanzitutto, questo articolo esaminerà i molti modi in cui l'output di git log può essere formattato. La maggior parte di questi si presenta sotto forma di flag che consentono di richiedere più o meno informazioni da git log.

Se non ti piace il formato predefinito di git log, puoi usare la funzionalità di aliasing di git config per creare una scorciatoia per una qualsiasi delle opzioni di formattazione discusse di seguito. Consulta Il comando git config per scoprire come configurare un alias.

Oneline

Il flag —oneline condensa ogni commit in un'unica riga. Per impostazione predefinita, mostra solo l'ID di commit e la prima riga del messaggio di commit. Il tuo tipico output di git log —oneline sarà simile al seguente:

10e25143 Merge branch 'feature'
2ad8621a Fix a bug in the feature
316b36c6 Add a new feature
423ad9ad Add the initial code base

Questo è molto utile per avere una panoramica generica sul tuo progetto.

Decorazione

Spesso è utile sapere a quale branch o tag è associato ogni commit. Il flag —decorate fa sì che git log mostri tutti i riferimenti (ad esempio, branch, tag, ecc.) che puntano a ciascun commit.

Questo può essere combinato con altre opzioni di configurazione. Ad esempio, l'esecuzione di git log —oneline —decorate formatterà la cronologia dei commit in questo modo:

10e25143 (HEAD, main) Merge branch 'feature'
2ad8621a (feature) Fix a bug in the feature
316b36c6 Add a new feature
423ad9ad (tag: v0.9) Add the initial code base

Questo ti fa sapere che anche il primo commit è stato sottoposto a checkout (indicato con HEAD) e che è anche la punta del branch principale. Un altro branch chiamato feature punta al secondo commit, e infine il quarto commit è etichettato come v0.9.

I branch, i tag, l'HEAD e la cronologia dei commit sono quasi tutte le informazioni contenute nel tuo repository Git, quindi questo ti offre una visione più completa della struttura logica del tuo repository.

Differenze

Il comando git log include molte opzioni per visualizzare le differenze relative a ogni commit. Due delle opzioni più comuni sono —stat e -p.

L'opzione —stat mostra il numero di inserimenti ed eliminazioni in ogni file modificato da ogni commit (si noti che la modifica di una riga è rappresentata da 1 inserimento e 1 eliminazione). Questo è utile quando desideri avere un breve riepilogo delle modifiche introdotte da ogni commit. Ad esempio, il seguente commit ha aggiunto 67 righe al file hello.py e rimosso 38 righe:

1commit f2a238924e89ca1d4947662928218a06d39068c3
2Author: John <john@example.com>
3Date:   Fri Jun 25 17:30:28 2014 -0500
4
5    Add a new feature
6
7 hello.py | 105 ++++++++++++++++++++++++-----------------
8 1 file changed, 67 insertion(+), 38 deletions(-)

La quantità di segni + e - accanto al nome del file mostra il numero relativo di modifiche apportate a ciascun file modificato dal commit. Questo ti dà un'idea di dove si possono trovare le modifiche per ogni commit.

Se vuoi vedere le modifiche effettive introdotte da ogni commit, puoi passare l'opzione -p a git log. Questo restituisce l'intera patch che rappresenta quel commit:

1commit 16b36c697eb2d24302f89aa22d9170dfe609855b
2Author: Mary <mary@example.com>
3Date:   Fri Jun 25 17:31:57 2014 -0500
4
5    Fix a bug in the feature
6
7diff --git a/hello.py b/hello.py
8index 18ca709..c673b40 100644
9--- a/hello.py
10+++ b/hello.py
11@@ -13,14 +13,14 @@ B
12-print("Hello, World!")
13+print("Hello, Git!")

Per i commit con molte modifiche, l'output risultante può diventare piuttosto lungo e ingombrante. Il più delle volte, se stai visualizzando una patch completa, probabilmente stai cercando una modifica specifica. Per questo, è utile usare l'opzione piccone.

Lo Shortlog

Il comando git shortlog è una versione speciale di git log destinata alla creazione di annunci di rilascio. Raggruppa ogni commit per autore e visualizza la prima riga di ogni messaggio di commit. Questo è un modo semplice per vedere chi sta lavorando su cosa.

Ad esempio, se due sviluppatori hanno contribuito con 5 commit a un progetto, l'output di git shortlog potrebbe essere il seguente:

1Mary (2):
2      Fix a bug in the feature
3      Fix a serious security hole in our framework
4
5John (3):
6      Add the initial code base
7      Add a new feature
8      Merge branch 'feature'

Per impostazione predefinita, git shortlog ordina l'output in base al nome dell'autore, ma puoi anche passare l'opzione -n per ordinare in base al numero di commit per autore.

grafici

L'opzione —graph disegna un grafico ASCII che rappresenta la struttura ramificata della cronologia dei commit. Questo è comunemente usato insieme ai comandi —oneline e —decorate per rendere più facile vedere quale commit appartiene a quale branch:

1git log --graph --oneline --decorate

Per un semplice repository con solo 2 branch, il risultato sarà il seguente:

1*   0e25143 (HEAD, main) Merge branch 'feature'
2|\  
3| * 16b36c6 Fix a bug in the new feature
4| * 23ad9ad Start a new feature
5* | ad8621a Fix a critical security issue
6|/  
7* 400e4b7 Fix typos in the documentation
8* 160e224 Add the initial code base

L'asterisco mostra in quale branch si trovava il commit, quindi il grafico sopra indica che i commit 23ad9ad e 16b36c6 si trovano su un branch tematico e il resto sul branch principale.

Sebbene questa sia una buona opzione per i repository semplici, probabilmente sarà più utile usare uno strumento di visualizzazione più completo come gitk o Sourcetree per progetti molto ramificati.

Formattazione personalizzata

Per tutte le altre tue esigenze di formattazione di git log, puoi usare l'opzione --pretty=format:"<string>". Questo ti consente di visualizzare ogni commit come preferisci utilizzando segnaposti in stile printf.

Ad esempio, i caratteri %cn, %h e %cd nel seguente comando sono sostituiti rispettivamente dal nome di chi ha eseguito il commit, dall'hash abbreviato del commit e dalla data dell'autore del commit.

1git log --pretty=format:"%cn committed %h on %cd"

Il risultato è il seguente formato per ogni commit:

1John committed 400e4b7 on Fri Jun 24 12:30:04 2014 -0500 John committed 89ab2cf on Thu Jun 23 17:09:42 2014 -0500 Mary committed 180e223 on Wed Jun 22 17:21:19 2014 -0500 John committed f12ca28 on Wed Jun 22 13:50:31 2014 -0500

L'elenco completo dei segnaposti è disponibile nella sezione Pretty Formats della pagina del manuale di git log.

Oltre a consentirti di visualizzare solo le informazioni che ti interessano, l'opzione --pretty=format:"<string>" è particolarmente utile quando stai cercando di reindirizzare l'output di git log a un altro comando.

Filtrare la cronologia dei commit

La formattazione del modo in cui ogni commit viene visualizzato è solo metà dell'impegno per imparare Git Log. L'altra metà è capire come navigare nella cronologia dei commit. Il resto di questo articolo introduce alcuni dei modi avanzati per selezionare commit specifici nella cronologia del progetto utilizzando git log. Tutti questi possono essere combinati con una qualsiasi delle opzioni di formattazione discusse sopra.

Per quantità

L'opzione di filtro più semplice per git log è limitare il numero di commit visualizzati. Quando sei interessato solo agli ultimi commit, questo ti evita la fatica di visualizzare tutti i commit in una pagina.

Puoi limitare l'output di git log includendo l'opzione -<n>. Ad esempio, il comando seguente mostrerà solo i 3 commit più recenti.

1git log -3

Per data

Se stai cercando un commit per un periodo di tempo specifico, puoi utilizzare i contrassegni —after o —before per filtrare i commit per data. Entrambi accettano una varietà di formati di data come parametri. Ad esempio, il comando seguente mostra solo i commit creati dopo il 1° luglio 2014 (incluso):

1git log --after="2014-7-1"

Puoi anche inserire riferimenti relativi come "1 settimana fa" e "ieri":

1git log --after="yesterday"

Per cercare un commit creato tra due date, puoi fornire sia una data —prima che una dopo. Ad esempio, per visualizzare tutti i commit aggiunti tra il 1 luglio 2014 e il 4 luglio 2014, userai quanto segue:

1git log --after="2014-7-1" --before="2014-7-4"

Per i commit con molte modifiche, l'output risultante può diventare piuttosto lungo e ingombrante. Il più delle volte, se stai visualizzando una patch completa, probabilmente stai cercando una modifica specifica. Per questo, è utile usare l'opzione piccone.

Per autore

Quando cerchi solo i commit creati da un determinato utente, usa il flag —author. Questa opzione accetta un'espressione regolare e restituisce tutti i commit il cui autore corrisponde a quel modello. Se sai esattamente chi stai cercando, puoi usare una semplice vecchia stringa invece di un'espressione regolare:

1git log --author="John"

Mostra tutti i commit il cui autore include il nome John. Il nome dell'autore non deve necessariamente corrispondere esattamente, deve solo contenere la frase specificata.

Puoi anche usare espressioni regolari per creare ricerche più complesse. Ad esempio, il comando seguente cerca i commit di Mary o John.

1git log --author="John\|Mary"

Nota che anche l'email dell'autore è inclusa con il nome dell'autore, quindi puoi usare questa opzione anche per cercare tramite email.

Se il tuo flusso di lavoro separa gli autori dei commit dagli autori, il flag —committer funziona nello stesso modo.

Per messaggio

Per filtrare i commit in base al messaggio di commit, usa il flag —grep. Questo funziona proprio come il flag —author di cui si è parlato sopra, ma esegue la corrispondenza in base al messaggio di commit anziché all'autore.

Ad esempio, se il tuo team include i numeri dei problemi pertinenti in ogni messaggio di commit, puoi usare un'espressione come quella di seguito per estrarre tutti i commit relativi a quel problema:

1git log --grep="JRA-224:"

Puoi anche passare il parametro -i a git log per fare in modo che ignori le differenze tra maiuscole e minuscole durante la corrispondenza dei modelli.

Per file

Molte volte, ti interessano solo le modifiche apportate a un determinato file. Per mostrare la cronologia relativa a un file, tutto ciò che devi fare è inserire il percorso del file. Ad esempio, l'espressione di seguito restituisce tutti i commit che hanno influito sul file foo.py o bar.py:

1git log -- foo.py bar.py

Il parametro — è usato per indicare a git log che gli argomenti successivi sono i percorsi dei file e non i nomi dei branch. Se non c'è alcuna possibilità di confusione con un branch, puoi omettere il —.

Per contenuto

È anche possibile cercare commit che introducono o rimuovono una determinata riga di codice sorgente. Questo si chiama piccone e assume la forma di una -S"<string>". Ad esempio, se vuoi sapere quando è stata aggiunta la stringa Hello, World! a un file del progetto, devi usare il comando seguente:

1git log -S"Hello, World!"

Se vuoi effettuare una ricerca utilizzando un'espressione regolare anziché una stringa, puoi invece usare il flag -G"<regex>".

Questo è uno strumento di debug molto potente, in quanto consente di individuare tutti i commit che influiscono su una determinata riga di codice. Può anche mostrarti quando una riga è stata copiata o spostata in un altro file.

Per intervallo

Puoi passare una serie di commit a git log in modo da mostrare solo i commit contenuti in quell'intervallo. L'intervallo è specificato nel seguente formato, dove <since> e <until> sono riferimenti di commit:

1git log <since>..<until>

Questo comando è particolarmente utile quando si utilizzano riferimenti di branch come parametri. È un modo semplice per mostrare le differenze tra 2 branch. Considera il seguente comando:

1git log main..feature

L'intervallo difunzionalità..principale contiene tutti i commit che si trovano nel branch delle funzionalità, ma non nel branch principale. In altre parole, si tratta dei progressi della funzionalità da quando è stata disattivata dal principale. Puoi visualizzarlo come segue:

Nota che se cambi l'ordine dell'intervallo (funzionalità..principale), otterrai tutti i commit nella sezione principale, ma non nella funzionalità. Se git log emette dei commit per entrambe le versioni, significa che la tua cronologia è diversa.

Filtraggio dei commit di fusione

Per impostazione predefinita, git log include i commit di fusione nell'output. Ma se il tuo team ha una politica di fusione continua (vale a dire che unisce le modifiche a monte in sezioni tematiche invece di ribasare il branch tematico sul branch upstream), avrai numerosi commit di fusione estranei nella cronologia del tuo progetto.

Puoi impedire a git log di visualizzare questi commit di fusione passando il flag —no-merges:

1git log --no-merges

D'altra parte, se sei interessato solo ai commit di fusione, puoi usare il flag —merges:

1git log --merges

Questo restituisce tutti i commit che hanno almeno due genitori.

Riepilogo

Ora dovresti sentirti abbastanza a tuo agio nell'usare i parametri avanzati di git log per formattare l'output e selezionare i commit che desideri visualizzare. Questo ti offre la possibilità di ottenere esattamente ciò di cui hai bisogno dalla cronologia del tuo progetto.

Queste nuove competenze sono una parte importante del tuo toolkit Git, ma ricorda che git log viene spesso usato insieme ad altri comandi Git. Una volta trovato il commit che stai cercando, di solito lo passi a git checkout, git revert o qualche altro strumento per manipolare la cronologia dei commit. Quindi, assicurati di continuare ad approfondire le funzionalità avanzate di Git.