04 - History
Comandi per esplorare la cronologia del repository e trovare informazioni su commit passati.
git log
Sintassi
git log [opzioni]
git log [opzioni] [<commit>] [--] [<path>]
Spiegazione
Mostra la cronologia dei commit. Il comando più usato per esplorare la storia del repository.
Esempi pratici
Log completo:
git log
Output:
commit abc123def456... (HEAD -> main, origin/main)
Author: Emanuele Gori <email@esempio.com>
Date: Mon Dec 23 10:30:00 2024 +0100
Add dark mode feature
Implements toggle for dark/light theme
with user preference persistence
commit 789ghi012jkl...
Author: Emanuele Gori <email@esempio.com>
Date: Sun Dec 22 15:20:00 2024 +0100
Fix authentication bug
Log compatto (una riga per commit):
git log --oneline
Output:
abc123d (HEAD -> main) Add dark mode feature
789ghi0 Fix authentication bug
def456a Update dependencies
Log con grafico branch:
git log --oneline --graph --all
Output:
* abc123d (HEAD -> main) Add dark mode
| * def456a (feature-api) Add API endpoints
|/
* 789ghi0 Fix auth bug
* 012jkl3 Initial commit
Log ultimi N commit:
git log -5 # Ultimi 5
git log -3 --oneline # Ultimi 3 compatti
Log con statistiche modifiche:
git log --stat
Output:
commit abc123...
Author: Emanuele Gori
Date: Mon Dec 23 10:30:00
Add dark mode feature
src/theme.css | 45 +++++++++++++++++++++++++++
src/app.js | 12 +++++--
2 files changed, 54 insertions(+), 3 deletions(-)
Log con patch (diff completo):
git log -p
git log -p -2 # Ultimi 2 con diff
Log per autore:
git log --author="Emanuele"
git log --author="emanuele@"
Log per data:
git log --since="2024-12-01"
git log --since="2 weeks ago"
git log --since="1 month ago"
git log --until="2024-12-20"
git log --since="2024-12-01" --until="2024-12-31"
Log per messaggio commit:
git log --grep="bug"
git log --grep="feature" --grep="fix" --all-match
Log per file specifico:
git log README.md
git log src/app.py
Log per file (seguendo rename):
git log --follow config.ini
Log commit che modificano codice specifico:
git log -S "function login" src/auth.js
Trova commit che aggiungono/rimuovono quella stringa.
Log formato personalizzato:
git log --pretty=format:"%h - %an, %ar : %s"
Output:
abc123d - Emanuele Gori, 2 days ago : Add dark mode
789ghi0 - Emanuele Gori, 1 week ago : Fix auth bug
Placeholder utili:
%H= commit hash completo%h= hash abbreviato%an= author name%ae= author email%ad= author date%ar= author date, relative%s= subject (messaggio)
Log commit di merge:
git log --merges # Solo merge
git log --no-merges # Escludi merge
Log tra due branch:
git log main..develop # Commit in develop non in main
git log develop..main # Commit in main non in develop
Log tra due date per autore:
git log --author="Emanuele" --since="1 month ago" --oneline
Log personalizzato (alias)
Aggiungi al .gitconfig:
git config --global alias.lg "log --graph --oneline --all --decorate"
git config --global alias.hist "log --pretty=format:'%h %ad | %s%d [%an]' --graph --date=short"
Uso:
git lg
git hist
Opzioni comuni
| Opzione | Descrizione |
|---|---|
--oneline |
Una riga per commit |
--graph |
Grafico ASCII |
--all |
Tutti i branch |
--stat |
Statistiche file |
-p, --patch |
Con diff |
-<n> |
Ultimi n commit |
--since, --until |
Filtro data |
--author |
Filtro autore |
--grep |
Filtro messaggio |
-S <string> |
Filtro codice |
--follow |
Segue rename |
--merges |
Solo merge |
--no-merges |
Escludi merge |
Note
git logmostra dal commit corrente all'indietro- Usa
qper uscire dal pager - Combina opzioni per query complesse
git show
Sintassi
git show [<commit>]
git show [opzioni] <commit>
Spiegazione
Mostra dettagli di uno specifico commit: messaggio, autore, data, modifiche (diff).
Esempi pratici
Mostrare ultimo commit:
git show
# oppure esplicitamente
git show HEAD
Mostrare commit specifico:
git show abc123
Mostrare commit relativo:
git show HEAD~1 # Penultimo commit
git show HEAD~3 # 3 commit fa
git show HEAD^ # Genitore di HEAD (primo)
git show HEAD^^ # Nonno di HEAD
Mostrare solo messaggio (no diff):
git show --no-patch abc123
# oppure
git show -s abc123
Mostrare solo nomi file modificati:
git show --name-only abc123
Mostrare file specifico da commit:
git show abc123:src/app.py
Mostra contenuto di app.py in quel commit.
Mostrare tag annotato:
git show v1.0.0
Mostrare statistiche modifiche:
git show --stat abc123
Formato compatto:
git show --oneline --no-patch abc123
Uso pratico
Esaminare commit prima di revert/reset:
# Vedi cosa contiene il commit
git show abc123
# Decidi se fare revert
git revert abc123
Recuperare file da commit vecchio:
# Vedi se il file esiste
git show abc123:config.ini
# Recupera file
git show abc123:config.ini > config-old.ini
Code review commit:
# Lista commit da revieware
git log --oneline -5
# Review dettagliato di ognuno
git show abc123
git show def456
Opzioni comuni
| Opzione | Descrizione |
|---|---|
--no-patch, -s |
Solo messaggio, no diff |
--stat |
Statistiche |
--name-only |
Solo nomi file |
--name-status |
Nomi + status |
--oneline |
Formato compatto |
--pretty=<format> |
Formato custom |
Note
git show=git log -p -1(circa)- Utile per ispezioni veloci di commit
- Combina con
git logper navigare storia
git blame
Sintassi
git blame <file>
git blame [opzioni] <file>
Spiegazione
Mostra chi ha modificato ogni riga di un file e in quale commit. Utile per trovare quando/da chi è stata introdotta una modifica.
Esempi pratici
Blame file completo:
git blame README.md
Output:
abc123d1 (Emanuele Gori 2024-12-20 10:30:00 +0100 1) # Progetto BoilerBot
def456a2 (Emanuele Gori 2024-12-22 15:20:00 +0100 2)
def456a2 (Emanuele Gori 2024-12-22 15:20:00 +0100 3) Sistema diagnostica caldaie
789ghi03 (Emanuele Gori 2024-12-23 09:00:00 +0100 4) con notifiche Telegram
Blame righe specifiche:
git blame -L 10,20 src/app.py
git blame -L 50,+10 src/app.py # Da riga 50, +10 righe
Blame formato compatto:
git blame -s README.md
Solo hash e riga (senza autore/data).
Blame ignorando whitespace:
git blame -w file.py
Blame mostrando email invece di nome:
git blame -e src/app.py
Blame da commit specifico:
git blame abc123 -- src/app.py
Mostra blame come era in quel commit.
Blame con commit message:
git blame -c README.md
Output più dettagliato con messaggio commit.
Uso pratico
Trovare chi ha introdotto un bug:
# 1. Trova riga con bug
git blame src/auth.py | grep "problematic_function"
# 2. Ottieni hash commit
# abc123d1 (...)
# 3. Vedi commit completo
git show abc123d1
# 4. Contatta autore o correggi
Tracciare evoluzione di funzione:
# Blame attuale
git blame -L 100,150 src/api.py
# Blame 6 mesi fa
git blame abc123 -L 100,150 src/api.py
Blame attraverso rename:
git blame -C -C -C file.py
Segue righe anche se file è stato rinominato/copiato.
Opzioni comuni
| Opzione | Descrizione |
|---|---|
-L <start>,<end> |
Range righe |
-s |
Formato corto |
-e |
Mostra email |
-w |
Ignora whitespace |
-C |
Rileva copie/rename |
-c |
Mostra messaggio |
--since |
Solo modifiche dopo data |
Note
- "Blame" non è per "colpevolizzare" ma per "attribuire"
- Utile per capire contesto modifiche
- Funziona meglio con commit piccoli e atomici
git reflog
Sintassi
git reflog
git reflog [opzioni]
Spiegazione
Mostra cronologia di TUTTI i movimenti di HEAD (branch switch, commit, reset, rebase, ecc.). È il "registro degli eventi" di Git - il tuo salvavita per recuperare lavoro perso.
Esempi pratici
Reflog completo:
git reflog
Output:
abc123d HEAD@{0}: commit: Add dark mode
789ghi0 HEAD@{1}: checkout: moving from develop to main
def456a HEAD@{2}: commit: Fix bug
012jkl3 HEAD@{3}: reset: moving to HEAD~1
345mno6 HEAD@{4}: commit (amend): Update docs
Reflog con date:
git reflog --date=iso
Reflog di branch specifico:
git reflog show develop
Reflog con diff:
git reflog -p
Uso pratico - Recuperare lavoro perso
Scenario 1: Reset accidentale
# Hai fatto reset perdendo commit
git reset --hard HEAD~3
# OH NO! Commit persi!
# 1. Guarda reflog
git reflog
# 2. Trova commit prima del reset
# abc123d HEAD@{1}: commit: Important work
# 3. Recupera
git reset --hard abc123d
Scenario 2: Branch eliminato per errore
# Eliminato branch importante
git branch -D feature-importante
# 1. Trova ultimo commit del branch nel reflog
git reflog | grep feature-importante
# 2. Ricrea branch
git branch feature-importante abc123d
Scenario 3: Rebase andato male
# Rebase rotto
git rebase main
# ...conflitti...
git rebase --abort
# MA hai perso qualcosa?
# 1. Trova stato prima del rebase
git reflog | grep "rebase"
# 2. Torna indietro
git reset --hard HEAD@{5}
Scenario 4: Commit amend perso:
# Fatto amend perdendo commit precedente
git commit --amend
# Reflog ha entrambe le versioni
git reflog
# Recupera versione pre-amend
git reset --hard HEAD@{1}
Reflog con time-travel
# Torna a stato di 2 ore fa
git reset --hard HEAD@{2.hours.ago}
# Torna a stato di ieri
git reset --hard HEAD@{yesterday}
# Torna a stato di 1 settimana fa
git reset --hard HEAD@{1.week.ago}
Limitazioni reflog
- Reflog è locale (non sincronizzato con remote)
- Default: conserva 90 giorni
- Commit unreachable vengono garbage collected dopo 30 giorni
- Non recupera modifiche mai committate
Opzioni comuni
| Opzione | Descrizione |
|---|---|
--date=iso |
Con date leggibili |
-<n> |
Ultimi n reflog |
show <branch> |
Reflog di branch |
-p |
Con diff |
--all |
Tutti i ref |
Note
- Reflog è il tuo paracadute - Git raramente perde davvero commit
- Funziona solo per repository locale
- Sempre controllabile prima di operazioni rischiose
- Non funziona per file mai aggiunti a Git
🔗 Collegamenti
- Precedente: ← Branching e Merging
- Prossimo: Sincronizzazione →
- Indice: ← Torna all'indice
📝 Riepilogo comandi
# LOG
git log # Cronologia completa
git log --oneline # Compatto
git log --graph --all # Grafico branch
git log -5 # Ultimi 5
git log --author="Nome" # Per autore
git log --since="1 week ago" # Per data
git log --grep="bug" # Per messaggio
git log -p file.txt # Storia file con diff
# SHOW
git show # Ultimo commit
git show abc123 # Commit specifico
git show HEAD~2 # 2 commit fa
git show --stat abc123 # Con statistiche
git show abc123:file.txt # File da commit
# BLAME
git blame file.txt # Chi ha modificato cosa
git blame -L 10,20 file.txt # Range righe
git blame -w file.txt # Ignora whitespace
# REFLOG
git reflog # Cronologia HEAD
git reflog show develop # Reflog branch
git reset --hard HEAD@{2} # Recupera stato precedente