Git: Consultazione della Cronologia dei Commit

Dopo aver effettuato diversi commit, oppure quando si clona un repository con una cronologia già esistente, è fondamentale poter analizzare lo storico delle modifiche.

Lo strumento principale messo a disposizione da Git per questo scopo è il comando git log, che consente di ispezionare in dettaglio l’evoluzione di un progetto.

Il comando più semplice è:

git log

L’output predefinito elenca i commit in ordine cronologico inverso, mostrando per ciascun commit:

• l’hash SHA-1 univoco
• l’autore con email
• la data
• il messaggio di commit

FIG 1 - git log

Opzioni utili di git log

Git mette a disposizione un’ampia gamma di opzioni per adattare l’output alle proprie esigenze.

1. Mostrare le modifiche introdotte da ciascun commit

git log -p -2

• L’opzione -p (o --patch) visualizza le differenze introdotte.
• Il parametro -2 limita l’output agli ultimi due commit.
• Utile in fase di code review o per analizzare l’evoluzione del codice.

FIG 2 - git log -p -2

2. Visualizzare statistiche sintetiche

git log --stat

Mostra i file modificati, il numero di righe aggiunte/rimosse e un riepilogo finale.

FIG 3 - git log --stat

git log --shortstat

Questo comando fornisce un riassunto molto conciso per ogni commit. Mostra un'unica riga con il conteggio totale dei file modificati e il numero totale di righe aggiunte e cancellate. Non elenca i nomi specifici dei file.

3. Formattazione personalizzata

Consente di definire un formato personalizzato dell’output, utile per generare report o output leggibili da script.

git log --pretty=format:"%h - %an, %ar : %s"

Segnaposto principali

Segnaposto	Descrizione
%H	Hash completo del commit
%h	Hash abbreviato
%T	Hash dell'albero
%t	Hash dell'albero abbreviato
%P	Hash dei genitori
%p	Hash dei genitori abbreviati
%an	Nome autore
%ae	Email autore
%ad	Data autore (formato configurabile con --date=)
%ar	Data autore relativa (es. “2 weeks ago”)
%cn	Nome committer
%ce	Email committer
%cd	Data del committer
%cr	Data del committer, relativa
%s	Messaggio del commit

FIG 4 - git log --pretty=format

4. Output compatti

• git log --oneline
  commit in una sola riga (hash abbreviato + messaggio).
• git log --pretty=short|full|fuller
  diversi livelli di dettaglio.
• git log --abbrev-commit
  mostra solo le prime cifre dell’hash.

FIG 5 - git log --oneline

5. Rappresentazione grafica

Visualizza un grafico ASCII che illustra la struttura di branch e merge, molto utile in repository complessi.

git log --graph

FIG 6 - git log --graph

Opzioni per limitare l'output di git log

Oltre alle opzioni di formattazione, il comando git log supporta numerose opzioni di limitazione, che consentono di filtrare i commit mostrati.

Queste opzioni sono utili per concentrarsi su un intervallo temporale, un autore, un file specifico o persino su modifiche particolari al codice.

1. Limitazione numerica

Per visualizzare solo gli ultimi n commit:

git log -2

Mostra solo gli ultimi due commit.

FIG 7 - git log -2

2. Limitazione temporale

È possibile filtrare i commit in base a date assolute o relative:

git log --since=2.weeks

git log --since="2025-01-01" --until="2025-01-31"

--since / --after  

commit successivi a una certa data.

--until / --before 

commit precedenti a una certa data.

Esempi validi di date:

"2008-01-15" (formato ISO)

"2 years 1 day 3 minutes ago" (relativo)

3. Filtrare per autore o committer

git log --author="Alice"

git log --committer="Bob"

--author  
mostra commit scritti da un certo autore.

--committer
mostra commit applicati da uno specifico committer.

É possibile utilizzare più di una regola --author o --grep contemporaneamente.

Con l’opzione --all-match, Git mostrerà solo i commit che soddisfano tutti i criteri.

4. Ricerca nei messaggi di commit

git log --grep="bugfix"

Mostra i commit che hanno "bugfix" nel messaggio di commit.

Può essere combinato con --author e --since per ricerche più precise.

5. Pickaxe: cercare modifiche nel codice

git log -S function_name

L’opzione -S (detta pickaxe) trova i commit in cui cambia il numero di occorrenze di una stringa (es. aggiunta o rimozione di una funzione).

Ottimo per capire quando e perché è stata introdotta o rimossa una porzione di codice.

6. Limitazione per file o directory

git log -- path/to/file

Mostra solo i commit che hanno modificato un file o una directory specifica.

Per separare chiaramente le opzioni dal percorso si usa --:

git log --since="2025-01-01" -- path/to/file

7. Evitare i merge commit

In repository con workflow basati su merge, la cronologia può risultare affollata.

Per nascondere i merge commit non informativi:

git log --no-merges

Tabelle riepilogative delle opzioni comuni

Opzione	Descrizione
-p o --patch	Mostra le differenze introdotte da ciascun commit
--stat	Riepilogo file modificati e righe aggiunte/rimosse
--shortstat	Solo il riepilogo numerico (senza elenco file)
--name-only	Elenco dei file modificati
--name-status	Elenco file + stato (A=Added, M=Modified, D=Deleted)
--abbrev-commit	Hash abbreviati
--relative-date	Date in formato relativo (“2 days ago”)
--graph	Grafico ASCII della cronologia
--pretty	Formati alternativi (oneline, short, full, fuller, format)
--oneline	Alias di --pretty=oneline --abbrev-commit. Mostra ogni commit su una singola riga

Opzioni di filtro

Opzione	Descrizione
-n <numero>	Limita il numero di commit visualizzati all'ultimo <numero> specificato
--author="<pattern>"	Filtra i commit in base all'autore. Accetta anche espressioni regolari.
--committer="<pattern>"	Filtra i commit in base al committer.
--grep="<pattern>"	Filtra i commit in base a un pattern nel messaggio del commit.
--since="<data>"	Visualizza i commit a partire da una data specificata("2 weeks ago", "2023-01-01", "yesterday").
--until="<data>"	Visualizza i commit fino a una data specificata.
--after="<data>"	Alias di --since
--before="<data>"	Alias di --until
<file-o-cartella>	Mostra solo i commit che hanno modificato un file o una cartella specifica
--merges	Mostra solo i commit di merge.
--no-merges	Esclude i commit di merge dalla visualizzazione.

Opzioni di navigazione

Opzione	Descrizione
--reverse	Limita il numero di commit visualizzati all'ultimo <numero> specificato
<start>..<end>	Filtra i commit in base all'autore. Accetta anche espressioni regolari.
-S"<stringa>" o --all-match-S"<stringa>"	Mostra i commit che hanno introdotto o rimosso una riga contenente una stringa specifica. Utile per il debugging.
-G"<regex>"	Simile a -S, ma usa un'espressione regolare per cercare le modifiche nel contenuto dei file

Differenza tra autore e committer

• Autore (Author): chi ha scritto originariamente la modifica.
• Committer: chi ha applicato la modifica al repository (può coincidere con l’autore o essere un maintainer che ha accettato una patch).

Questo permette di riconoscere sia chi ha prodotto il codice sia chi ne ha garantito l’integrazione

Esempio avanzato

Visualizzare i commit:

• scritti da Giovanni Lubrano Lavadera,
  
• nel mese di novembre 2024,
• che non siano merge commit,
• relativi alla directory test/

git log --pretty="%h - %s" \
  --author="Giovanni Lubrano Lavadera" \
  --since="2024-11-01" \
  --before="2024-12-01" \
  --no-merges -- test/

Git: Gestione dello spostamento e rinomina dei file

A differenza di molti altri sistemi di controllo versione (VCS), Git non memorizza esplicitamente i metadati relativi allo spostamento o alla rinomina dei file.

Quando un file viene rinominato o spostato, Git non registra direttamente questa operazione, ma è in grado di riconoscerla in maniera implicita analizzando le differenze tra le versioni dei file al momento del commit.

Nonostante ciò, Git fornisce il comando git mv, che semplifica l’operazione di rinomina o spostamento di un file, integrando in un’unica istruzione le operazioni necessarie.

Esempio di utilizzo

git mv Readme.txt ReadmeFirst.txt

git status

L'output sarà quello visualizzato in FIG 1.

FIG 1 - Rinomina file con git mv

In questo caso, Git riconosce il file come rinominato e lo segnala chiaramente nello staging area.

Il comando git mv è una scorciatoia che racchiude in un’unica istruzione tre operazioni normalmente necessarie:

1. Rinomina a livello di filesystem
   mv Readme.txt ReadmeFirst.txt 
   
2. Rimuove il vecchio file dall’indice
   git rm Readme.txt
3. Aggiunge il nuovo file all’indice
   git add README

Il risultato finale è identico: Git rileva la rinomina al momento del commit, indipendentemente da come sia stata eseguita.

Vantaggi dell’uso di git mv

• Maggiore semplicità: un solo comando invece di tre.
• Maggiore chiarezza: rende esplicita l’intenzione di rinominare o spostare un file.
• Integrazione fluida nello staging: evita errori di dimenticanza (ad esempio eseguire mv ma non aggiornare l’indice).

Best Practice

• Utilizzare git mv per rendere più chiaro lo storico dei comandi ed evitare passaggi manuali.
• In progetti complessi, verificare sempre con git status che la rinomina sia stata rilevata correttamente.
• Ricordare che Git determina la rinomina per similarità di contenuto: se il file rinominato è stato pesantemente modificato, potrebbe non essere riconosciuto automaticamente come rename ma come delete + add.

Git: Rimozione dei file

La gestione della rimozione dei file in Git non si limita a cancellarli dal file system: occorre infatti aggiornare anche l’indice (staging area) affinché il VCS tenga traccia della loro eliminazione. A questo scopo si utilizza il comando git rm, che rimuove un file sia dalla working directory sia dall’area di staging, garantendo così che il cambiamento venga registrato nel prossimo commit.

Se invece un file viene eliminato manualmente dal file system (ad esempio con rm nomefile in Linux/Mac o del nomefile in Windows), Git rileverà la cancellazione come una modifica non tracciata e la segnalerà con lo stato deleted nel comando git status. In questo scenario, per allineare il repository occorre esplicitamente eseguire:

git rm nomefile

git commit -m "Remove nomefile"

FIG 1 - git rm

Opzioni principali di git rm

• git rm file
  Rimuove il file dalla working directory e dall’indice, pronto per essere eliminato con il commit successivo.
• git rm -f file (force)
  Utilizzato quando il file modificato o già in staging non può essere rimosso normalmente. Serve a prevenire la perdita di dati non ancora salvati in un commit.
• git rm -r nomecartella
  Rimuove la cartella dalla working directory e dall’indice. La cartella e i file contenuti verranno eliminati con il commit successivo.
• git rm --cached file
  Rimuove il file solo dall’indice, mantenendolo nel file system locale. È utile quando si vogliono escludere file già tracciati (ad esempio log, binari o configurazioni locali) che dovrebbero essere ignorati in futuro tramite .gitignore.
• Supporto a directory e pattern
  È possibile passare intere cartelle o utilizzare glob patterns:
  git rm log/\*.log     # rimuove tutti i file .log in log/  
  git rm *~            # rimuove tutti i file temporanei terminanti con ~
  
  Attenzione: occorre fare escaping (\*) se si vuole che il pattern venga interpretato da Git e non dalla shell.

Tabella di confronto: modalità di rimozione

Comando	Effetto sul file system	Effetto sull’indice (staging)	Caso d’uso tipico
rm file / del file	Elimina il file solo dal disco	Segnalato come deleted ma non ancora tracciato	Eliminazione manuale, da completare con git rm
git rm file	Elimina dal disco e dall’indice	File rimosso e pronto al commit	Rimozione standard di file tracciati
git rm -r cartella	Elimina dal disco e dall’indice	Cartella rimossa e pronto al commit	Rimozione standard di cartelle tracciate
git rm -f file	Forza l’eliminazione anche se modificato	File rimosso forzatamente	Prevenire conflitti con file non ancora committati
git rm --cached file	Mantiene il file nel disco	Rimosso dall’indice	Escludere file dal versionamento (es. log, build, config locali)
git rm pattern (es. *.log)	Elimina più file secondo il pattern	Tutti i file corrispondenti rimossi	Pulizia massiva di file generati automaticamente

 

Best practice

• Prima di utilizzare git rm -f, verificare se le modifiche devono essere salvate: in caso positivo, effettuare un commit preventivo.
• Utilizzare git rm --cached in combinazione con un aggiornamento del .gitignore, per evitare di reintrodurre accidentalmente file indesiderati.
• Per rimuovere directory intere, aggiungere l’opzione -r (git rm -r nomecartella).
• In ambienti Windows, ricordare che del elimina il file solo dal disco: per rimuoverlo correttamente dal repository è necessario seguire con git rm.

Git: Commit senza passare dall’Area di Staging

L’area di staging rappresenta uno degli elementi chiave di Git, in quanto consente di preparare con precisione il contenuto di ogni commit. Tuttavia, in determinati contesti operativi, questa fase intermedia può risultare superflua e introdurre complessità non necessarie.

Per semplificare il flusso di lavoro, Git mette a disposizione un’opzione che consente di saltare lo staging: l’utilizzo del flag -a insieme al comando git commit. Il comando:

git commit -a -m "Messaggio del commit"

esegue automaticamente lo staging di tutti i file già tracciati (tracked) che risultano modificati o eliminati, evitando quindi la necessità di richiamare manualmente git add.

Esempio pratico

Supponiamo di trovarci nella situazione mostrata in FIG1 in cui il file Readme.txt, tracciato, è stato modificato ma non aggiunto all'area di staging e il file Leggimi.txt non tracciato.

FIG 1 - Git status

Eseguendo il comando

git commit -a -m "Aggiunte note a Readme.txt"

il file Readme.txt,  pur non essendo stato esplicitamente aggiunto con git add, viene comunque incluso nel commit grazie al flag -a.

FIG 2 - git commit -a

Il file Leggimi.txt non viene incluso nel commit in quanto si tratta di un file nuovo non tracciato.

FIG 3 - Stato dei file dopo gti commit -a

Limitazioni importanti

L’opzione -a funziona solo per i file già tracciati. Ciò significa che:

• i nuovi file (non ancora aggiunti con git add) non saranno inclusi nel commit;
• i file ignorati tramite .gitignore continueranno a essere esclusi;
• i file rimossi manualmente dal filesystem vengono comunque registrati come eliminati.

Vantaggi e rischi

L’utilizzo del flag -a può risultare particolarmente utile in contesti in cui si lavora su commit veloci e incrementali, riducendo i passaggi necessari. Tuttavia, presenta anche alcune criticità:

Vantaggi

• Semplificazione del flusso di lavoro.
• Minore rischio di dimenticare file modificati già tracciati.
• Maggiore rapidità in operazioni di manutenzione o correzioni veloci (hotfix).

Rischi

• Possibile inclusione di modifiche indesiderate (ad esempio righe di debug temporanee).
• Minore controllo fine sul contenuto del commit rispetto allo staging manuale.

Best Practice

Per utilizzare in modo efficace git commit -a, è consigliabile:

• Usarlo solo per commit semplici e poco critici (es. piccole correzioni o aggiornamenti rapidi).
• Evitare di utilizzarlo in commit complessi, dove è preferibile selezionare manualmente i file da includere nello staging.
• Combinare con git diff o git diff --staged per verificare le modifiche prima di finalizzare il commit.
• Non dimenticare i file nuovi, che richiedono comunque un git add esplicito.

Comando	Funzionamento	File inclusi nel commit	Quando utilizzarlo
git commit	Crea un commit solo con i file già presenti nello staging	Solo i file aggiunti esplicitamente con git add	Quando si desidera controllo totale sul contenuto del commit.
git commit -a	Esegue automaticamente lo staging di tutti i file già tracciati modificati o eliminati, prima del commit.	File già tracciati (modificati o rimossi), non i nuovi file	Per modifiche rapide o manutenzioni veloci, senza passare dallo staging.
git commit -am "msg"	Combina il comportamento di -a con l’aggiunta del messaggio inline (-m).	Come -a, ma con messaggio direttamente in linea	Per commit veloci con messaggio breve (es. hotfix, piccole correzioni).

Git: Commit

Una volta predisposta l’area di staging con le modifiche desiderate, è possibile procedere alla creazione di un commit. È importante ricordare che eventuali file ancora non aggiunti allo staging, ovvero quelli che sono stati creati o modificati ma per i quali non è stato eseguito il comando git add, non verranno inclusi nel commit corrente. Tali file rimarranno nello stato di modified nella working directory e potranno essere aggiunti successivamente.

Supponiamo, ad esempio, che l’ultimo comando git status abbia mostrato che tutte le modifiche risultano già correttamente inserite nello staging. In questo caso, è possibile eseguire il commit con il comando più semplice:

git commit

L’esecuzione del comando apre l’editor di testo configurato come predefinito (ad esempio Vim o Emacs), determinato dalla variabile d’ambiente EDITOR della shell. Tale editor può essere modificato a piacere tramite:

git config --global core.editor "<nome_editor>"

All’interno dell’editor viene mostrato un template che include:

• una riga vuota in cui inserire il messaggio di commit;
• un riepilogo delle modifiche in formato commentato, generato automaticamente da git status.

Le righe precedute dal carattere # sono considerate commenti e non vengono salvate nel commit. È possibile rimuoverle o lasciarle come promemoria.

FIG 1 - git commit

Per avere un contesto ancora più dettagliato, è possibile utilizzare l’opzione -v:

git commit -v

FIG 2 - git commit -v

In questo caso, oltre al riepilogo, viene mostrato anche il diff delle modifiche, consentendo di verificare con precisione quali linee di codice saranno incluse nel commit.

In alternativa, è possibile specificare il messaggio direttamente da riga di comando con l’opzione -m:

git commit -m "Modifica Projects1.cs"

Il messaggio deve essere chiaro, conciso e descrittivo, in modo da facilitare la comprensione della cronologia del progetto. È buona pratica adottare convenzioni uniformi all’interno del team di sviluppo (ad esempio includere ID di ticket o issue).

Output del commit

Dopo la conferma, Git fornisce un breve riepilogo contenente:

• il branch su cui è stato eseguito il commit (es. master o main);
• l’hash SHA-1 che identifica in maniera univoca il commit;
• il numero di file modificati;
• le statistiche sulle linee aggiunte e rimosse.

FIG 3 - Output commit

Il commit come snapshot

È fondamentale sottolineare che un commit non registra semplicemente le differenze, ma rappresenta un vero e proprio snapshot dello stato del progetto nell’area di staging in quel momento. Tutti i file non inclusi nello staging rimarranno inalterati nella working directory e potranno essere oggetto di un commit successivo.

Ogni commit diventa così una tappa storica nel ciclo di vita del progetto, alla quale è possibile tornare in caso di necessità, oppure confrontarla con versioni più recenti per analizzare l’evoluzione del codice.

Best Practice per i Messaggi di Commit

Un commit efficace non riguarda solo il codice, ma anche la documentazione della modifica. Scrivere messaggi chiari e coerenti consente a chiunque (incluso il sé stesso futuro) di comprendere rapidamente la storia del progetto.

Ecco alcune linee guida ampiamente riconosciute:

1. Usare un titolo breve e descrittivo

• Limitare la prima riga a 50 caratteri circa.
• Utilizzare il modo imperativo (es. “Fix bug”, “Add feature”, “Refactor code”) per descrivere l’azione.

2. Aggiungere una descrizione più dettagliata se necessario

• Inserire una riga vuota dopo il titolo.
• Fornire ulteriori spiegazioni sul perché della modifica, non solo sul cosa è stato cambiato.

3. Fare commit atomici

• Ogni commit deve contenere una modifica logica unica e indipendente.
• Evitare commit che mescolano refactoring, correzioni e nuove funzionalità.

4. Riferirsi a ticket o issue

• Quando si lavora in team con strumenti come Jira, GitHub o GitLab, citare l’ID del ticket o il numero dell’issue. Ad esempio: 
  git commit -m "Fix #182: corregge l’errore di serializzazione JSON"

5. Seguire convenzioni standardizzate

• Molti team adottano lo schema dei Conventional Commits, che prevede prefissi come:
  - feat: per nuove funzionalità
  - fix: per bugfix
  - docs: per modifiche alla documentazione
  - refactor: per miglioramenti interni al codice
  - test: per aggiunta o modifica di test
  
  Esempio:
  feat(auth): aggiunta autenticazione tramite OAuth2

6. Evitare messaggi generici

• Non usare commit come "update", "fix bug", "varie modifiche".
• Essere sempre specifici.

Git: Visualizzare le modifiche tracciate e non tracciate

Il comando git status fornisce una panoramica dello stato del repository, ma talvolta può risultare troppo generico: mostra quali file sono stati modificati, senza però evidenziare nel dettaglio quali righe siano cambiate.

Per ottenere una visione più approfondita delle differenze, è possibile utilizzare il comando git diff, che permette di ispezionare direttamente le modifiche a livello di contenuto.

In particolare, il comando git diff consente di ottenere risposte a due quesiti fondamentali:

• Quali modifiche sono state effettuate ma non ancora aggiunte all’area di staging?
• Quali modifiche risultano già presenti nello staging e che, di conseguenza, verranno incluse nel prossimo commit?

Differenze tra file modificati e staging area

Supponiamo, ad esempio, di modificare il file Readme.txt e di aggiungerlo allo staging con git add, mentre contestualmente modifichiamo il file Project1.cs senza però metterlo in staging.

Un comando git status restituirà un output simile a quello mostrato in FIG 1

FIG 1 - git status

In questa situazione, se eseguiamo:

git diff

Git ci mostrerà le modifiche presenti nel working directory ma non ancora aggiunte allo staging. Questo output, detto patch, include esattamente le righe aggiunte (+) e rimosse (-) nei file.

FIG 2 - git diff

Al contrario, se desideriamo visualizzare le differenze già pronte per il prossimo commit, dobbiamo usare:

git diff --staged

oppure, in alternativa:

git diff --cached

(--staged e --cached sono sinonimi). Questo comando confronta le modifiche presenti nello staging con l’ultimo commit registrato.

FIG 3 - git diff --staged

Caso pratico: modifiche sia staged che unstaged

Può accadere che lo stesso file venga modificato, aggiunto allo staging e poi ulteriormente modificato senza essere riaggiunto. In questo caso, git diff e git diff --staged mostrano rispettivamente:

• le differenze non ancora aggiunte,
• le differenze già pronte per essere salvate nel commit successivo.

Questo scenario è comune durante lo sviluppo, e l’uso combinato dei due comandi consente di avere il massimo controllo su ciò che sarà effettivamente registrato nella cronologia del progetto.

Nota importante: È bene sottolineare che git diff, se usato da solo, non mostra tutte le modifiche rispetto all’ultimo commit, ma solo quelle ancora unstaged.

Se tutte le modifiche sono state aggiunte allo staging, il comando non produrrà alcun output. In questi casi, l’opzione --staged è necessaria per visualizzare le differenze.

Utilizzo di strumenti esterni: git difftool

Per chi preferisce un’interfaccia grafica o un visualizzatore esterno, Git mette a disposizione il comando git difftool. Questo consente di analizzare le differenze utilizzando software come vimdiff, meld, kdiff3, o strumenti commerciali come Beyond Compare e Araxis Merge.

FIG 4 - git difftool, richiesta avvio tool per la comparazione

FIG 5 - Differenze nel file Project1.cs

Per scoprire quali strumenti sono disponibili sul proprio sistema:

git difftool --tool-help

È possibile configurare uno strumento di default nel file di configurazione globale:

git config --global diff.tool meld

Da quel momento, eseguendo git difftool senza ulteriori opzioni, Git aprirà automaticamente le differenze nell’applicativo scelto.

Best practices

• Usare spesso git diff: controllare con regolarità le differenze riduce il rischio di commettere modifiche indesiderate.
• Verificare prima di committare: un git diff --staged prima di eseguire il commit assicura che solo le modifiche realmente volute vengano salvate nella cronologia.
• Configurare strumenti grafici: in progetti complessi, visualizzatori esterni possono facilitare l’analisi di modifiche estese.

Di seguito una tabella riepilogativa dei principali comandi di Git usati per analizzare lo stato dei file e le modifiche:

Comando	Scopo principale	Cosa mostra	Quando usarlo	Output
git status	Fornisce una panoramica dello stato del repository	Elenco dei file modificati, non tracciati, staged o unstaged	Per avere una visione generale prima di committare	Testuale, descrittivo (ma non mostra le differenze riga per riga)
git diff	Mostra le modifiche non ancora aggiunte allo staging (unstaged)	Differenze tra working directory e staging area	Per sapere esattamente cosa è cambiato nei file non ancora aggiunti	Patch con righe aggiunte (+) e rimosse (-)
git diff --staged (o git diff --cached)	Mostra le modifiche già aggiunte allo staging	Differenze tra staging area e ultimo commit	Per verificare cosa verrà incluso nel prossimo commit	Patch dettagliata delle modifiche staged
git difftool	Visualizza le differenze con uno strumento esterno	Identico a git diff (staged o unstaged, a seconda dei parametri), ma in interfaccia grafica o editor	Per analizzare modifiche complesse o in progetti estesi	Dipende dallo strumento scelto (es. vimdiff, meld, Beyond Compare, ecc.)

New Outlook: Guida agli switch da riga di comando

Con l’introduzione di New Outlook, Microsoft non si è limitata a rinnovare l’interfaccia e a uniformare l’esperienza tra la versione desktop e quella web. Anche gli strumenti di amministrazione e diagnostica sono cambiati profondamente, inclusa la gestione degli switch da riga di comando, che risultano oggi molto differenti da quelli disponibili nel Classic Outlook.

Se nel client storico gli switch erano spesso usati per semplificare flussi di lavoro o integrare Outlook in procedure automatizzate, nella nuova versione l’obiettivo principale è spostato sul troubleshooting e sul supporto tecnico. Nonostante ciò, conoscere questi comandi può rivelarsi estremamente utile, soprattutto per amministratori IT, professionisti del supporto e power user.

In questo articolo analizzeremo sia gli switch documentati ufficialmente da Microsoft, sia quelli "nascosti", meno noti ma non meno interessanti, che consentono di ottenere un controllo più granulare sul comportamento dell’applicazione.

Utilizzo degli switch da riga di comando

L’esecuzione di uno switch in New Outlook segue una procedura relativamente semplice:

1. Premere la combinazione di tasti WIN+R  per aprire la finestra Esegui (oppure clic destro sul menu Start->Esegui).
2. Digitare olk.exe seguito da uno spazio.
3. Inserire due trattini (--) e il nome dello switch desiderato. 
   Ad esempio:
   olk.exe --safe
   
4. Premere Invio o fare clic su OK.

In questo modo Outlook si avvierà applicando il parametro selezionato.

FIG 1 - Finestra Esegui

Panoramica degli switch disponibili

Gli switch di New Outlook si dividono in due categorie:

• Documentati: elencati ufficialmente da Microsoft.
• Non documentati: scoperti tramite reverse engineering o sperimentazione e non sempre garantiti in termini di compatibilità futura.

Switch documentati

Switch	Descrizione
--clearLocalState	Cancella i file locali, la cache di WebView2 e riporta l’app allo stato "prima esecuzione". Utile per risolvere problemi di corruzione dati.
--force-update	Forza un controllo aggiornamenti di New Outlook.
--profile <nome>	Specifica il profilo di configurazione da utilizzare. Attualmente la funzionalità risulta limitata.
--safe	Avvia Outlook in modalità sicura, disabilitando PST, S/MIME, uso offline, configurazioni client non predefinite e componenti aggiuntivi Web.

Switch non documentati

Switch	Descrizione
--authloglevel <0-6>	Imposta il livello di log per l’autenticazione (0 = disattivato, 6 = massimo dettaglio).
--devtools	Attiva gli strumenti di sviluppo basati su Edge.
--offline	Disattiva i controlli offline, forzando l’avvio in modalità online.
--packageLogs	Genera un pacchetto locale con i log da condividere con il supporto tecnico.
--pos=<parametri>	Controlla posizione e dimensioni della finestra di Outlook (utile in configurazioni multi-monitor). I parametri da passare a pos sono valori separati da virgola che rappresentano la struttura WindowPlacement: rcNormal (sinistra, alto, destra, basso), versione, rcWork (sinistra, alto, destra, basso), dpi, showCmd, flag. Esempio: Per avviare Outlook nell'angolo superiore sinistro, con dimensioni 1200×800, su un monitor 1920×1080 con la barra delle applicazioni abilitata, configurato con 96 dpi; olk.exe --pos=0,0,1200,800,1,0,0,1920,1032,96,1,0
--recovery	Avvia Outlook in modalità di ripristino, simile a --safe ma con comportamenti più mirati al recupero della sessione.

Scenari di utilizzo pratico

• Supporto tecnico: con --clearLocalState o --packageLogs è possibile preparare rapidamente un ambiente "pulito" o fornire dati diagnostici al supporto Microsoft.
• Sviluppo e debug: lo switch --devtools permette di accedere alla console DevTools per analizzare il comportamento delle interfacce basate su WebView2.
• Gestione multi-monitor: grazie a --pos, gli amministratori possono predisporre avvii in posizioni e dimensioni predefinite, riducendo disallineamenti su workstation complesse.

Considerazioni finali

Gli switch da riga di comando in New Outlook riflettono la transizione verso un’applicazione ibrida, sempre più vicina a un’app web containerizzata, e meno a un classico client desktop. La riduzione delle opzioni di automazione è compensata da strumenti di diagnostica più avanzati, pensati per scenari enterprise e per semplificare le attività di troubleshooting.

Git: Ignorare i file con .gitignore

Spesso, all’interno di un progetto, esistono categorie di file che non si desidera vengano tracciati da Git né mostrati come untracked. Si tratta generalmente di file generati automaticamente, come log, file temporanei, file binari compilati o output di sistemi di build.

Per gestire questi casi, Git mette a disposizione il file speciale .gitignore, nel quale è possibile definire dei pattern che indicano i file o le directory da escludere dal controllo di versione.

Il file .gitignore è un semplice file di testo e il suo contenuto può essere del tipo:

# ignora tutti i file con estensione .a

*.a

# ma non ignorare lib.a

!lib.a

# ignora tutti i file con estensione .o o .a (tipici file oggetto o archivio generati da compilazioni).

*.[oa]

# ignora file con estensione .log e .tmp

*.log

*.tmp

# ignora le cartelle il cui nome inizia per Backup

Backup*/

Predisporre un file .gitignore fin dall’inizio del progetto è una buona pratica, perché evita di commettere accidentalmente file che non dovrebbero entrare nel repository.

Regole di base per i pattern in .gitignore

• Le righe vuote o quelle che iniziano con # sono ignorate (commenti).
• I glob pattern standard funzionano e vengono applicati ricorsivamente a tutta la working tree.
• Un pattern che inizia con / evita la ricorsività e si applica solo alla directory corrente.
• Un pattern che termina con / indica una directory intera.
• Un pattern che inizia con ! nega la regola, quindi forza il tracciamento di file che sarebbero altrimenti ignorati.

Glob pattern supportati
I glob pattern sono simili a espressioni regolari semplificate, comunemente usate nelle shell:

• *
  corrisponde a zero o più caratteri.
• [abc]
  corrisponde a un carattere tra quelli indicati (in questo caso a, b o c).
• ?
  corrisponde a un singolo carattere qualsiasi.
• [0-9]
  corrisponde a un carattere numerico da 0 a 9.
• **
  consente di corrispondere a directory nidificate (es. a/**/z corrisponde a a/z, a/b/z, a/b/c/z ecc.).

Normalmente, un progetto utilizza un unico file .gitignore nella directory principale, applicato ricorsivamente. Tuttavia, è possibile definire .gitignore aggiuntivi in sottodirectory: in questo caso, le regole si applicano solo ai file presenti sotto quella directory.

Per una descrizione completa delle regole supportate, è possibile consultare la pagina di manuale ufficiale con:

man gitignore

File .gitignore globali

Oltre ai .gitignore locali (specifici del progetto), è possibile definire un .gitignore globale valido per tutti i repository sullo stesso computer. Questo è utile per ignorare file tipici dell’ambiente di sviluppo personale (es. editor, IDE, sistema operativo).

Per configurarlo:

git config --global core.excludesfile C:/Users/<utente>/.gitignore_global

Git: Stato dei file

Uno degli strumenti principali per conoscere lo stato dei file all’interno di un repository è il comando:

git status

Se eseguito immediatamente dopo la clonazione di un repository, l’output potrebbe essere simile a quello mostrato in FIG 1.

FIG 1 - Nothing to commit

Questo messaggio indica che la working directory è "pulita": nessun file tracciato è stato modificato e non esistono file non tracciati. Inoltre, il comando segnala il ramo corrente (in questo caso master) e l'eventuale stato di sincronizzazione con il corrispondente ramo remoto (Ad esempio con il messaggio Your branch is up to date with 'origin/master'.).

Gestione nuovo file

Supponiamo di creare, all'interno della cartella del progetto, un nuovo file Readme.txt. Rieseguendo il comando git status avremo il messaggio mostrato in FIG 2.

FIG 2 - Untracked files

Come si può osservare, il file Readme.txt compare nella sezione Untracked files. Questo significa che Git lo rileva nella directory di lavoro, ma non lo sta ancora monitorando. Tale comportamento impedisce di includere accidentalmente file temporanei, binari generati o altri elementi non desiderati.

Per iniziare a tracciare il file è necessario utilizzare il comando:

git add Readme.txt

Eseguendo nuovamente git status si ottiene quanto mostrato in FIG 3.

FIG 3 - Changes to be committed

Ora Readme.txt risulta staged e pronto per essere incluso nel prossimo commit.

Gestire file modificati

Se si modifica un file già tracciato, ad esempio form.cs, l’output sarà simile a quello mostrato in FIG 4

FIG 4- Modified

Il file form.cs appare nella sezione Changes not staged for commit, a indicare che è stato modificato ma non ancora aggiunto allo staging. Per includerlo, si utilizza nuovamente git add:

git add form.cs

Eseguendo git status si vedrà che entrambi i file (Readme.txt e form.cs) sono ora pronti per il commit (FIG 5).

FIG 5 - Changes to be committed

Modifiche ulteriori su file già in staging

Può accadere di modificare nuovamente un file già aggiunto allo staging. In tal caso, lo stesso file apparirà in due sezioni contemporaneamente. Supponiamo di modificare nuovamente il file form.cs. Andando a visualizzare lo stato dei file con git status avremo la situazione mostrata in FIG 6.

FIG 6 - Modifica file già in staging

Il file modificato, form.cs, appare in due sezioni:

• Changes to be committed: rappresenta la versione del file già aggiunta allo staging.
• Changes not staged for commit: rappresenta la nuova versione del file, ancora non inclusa.

Questo comportamento è dovuto al fatto che Git memorizza nello staging area l’esatta istantanea del file al momento in cui è stato eseguito git add. Se il file viene modificato successivamente, per aggiornare l’istantanea occorre eseguire nuovamente:

git add form.cs

In questo modo, la versione aggiornata del file verrà inclusa nel prossimo commit.

Short Status

L’output del comando git status è piuttosto dettagliato, ma può risultare prolisso in alcune circostanze. Per questo motivo, Git mette a disposizione una modalità compatta tramite i flag:

git status -s

oppure

git status --short

Il risultato è una rappresentazione semplificata delle modifiche presenti nella working directory e nell’area di staging (FIG 7).

FIG 7 - Short Status

L'output del comando è composto da due colonne più il nome del file:  la colonna di sinistra (caratteri di colore verde) rappresenta lo stato del file nell’area di staging mentre quella di destra (caratteri di colore rosso) rappresenta lo stato del file nella working directory. 

Significato dei simboli

• ?? → file non tracciato (non incluso nello staging, nuovo file).
• A → file aggiunto allo staging (tracked per la prima volta).
• M → file modificato.
• D → file eliminato.
• R → file rinominato.
• C → file copiato.

Riassumendo

• git status è lo strumento di riferimento per monitorare lo stato della working directory.
• git add serve non solo ad aggiungere nuovi file al versionamento, ma anche ad aggiornare le modifiche di file già tracciati.
• Lo staging rappresenta uno snapshot intermedio: il commit fotografa esattamente i contenuti presenti nello staging al momento dell’esecuzione di git commit.