Git Config Username: la guida completa a commit puliti

Risposta rapida: come impostare il tuo username Git

Ecco i due comandi che ti servono:

# Set Git username globally (all repos)
git config --global user.name "Your Name"

# Set Git username for the current repo only
git config user.name "Your Name"

La configurazione globale si applica a ogni repository sulla tua macchina, a meno che un repo specifico non la sovrascriva.

Il comando semplice git config (senza --global) influisce solo sul repository in cui ti trovi.

Esegui questo comando per verificare cosa userà Git per il prossimo commit:

git config user.name

Mostra lo username attivo per la posizione corrente: o l’impostazione locale del repo o, se non esiste, il valore globale come fallback.

git config user.name

Mostra lo username attivo per la posizione corrente: o l’impostazione locale del repo o, se non esiste, il valore globale come fallback.

Informazioni su Git username e identità

Git inserisce due informazioni in ogni commit che fai: un nome autore e un’email autore.

Questi valori provengono direttamente da user.name e user.email nella tua config di Git. Quando esegui git commit, Git prende i valori impostati e li applica in modo permanente ai metadati del commit. I tuoi compagni li vedono in git log, nelle viste blame e nelle pull request.

Git non valida nessuna di queste informazioni.

Puoi impostare il tuo nome a "Batman", "Linus Torvalds" o solo nome e iniziale del cognome. Chi tiene alla privacy spesso usa pseudonimi o handle invece del nome completo, soprattutto per lavori open-source pubblici. A Git non interessa: registra solo ciò che gli dici di registrare.

L’unica cosa da ricordare è che il tuo Git username non è lo stesso del tuo username GitHub.

Il tuo Git username (user.name) è ciò che configuri in locale. Il tuo username GitHub è il tuo handle account, ovvero ciò che compare negli URL come github.com/your-handle. Sono sistemi completamente separati e non devono coincidere.

Piattaforme di hosting come GitHub e GitLab usano la tua email per collegare i commit al tuo account. Il nome è solo a scopo di visualizzazione. Se l’email del commit corrisponde a un’email presente nel tuo account GitHub, GitHub mostrerà la tua immagine profilo e il link al tuo account. Il nome che imposti in user.name compare come testo, ma è l’email che fa il vero lavoro di collegare i commit a te.

Cambiare user.name influisce solo sui commit futuri. I commit già pushati mantengono il nome autore originale.

Come funziona git config per user.name

Git salva le impostazioni di configurazione in tre posizioni diverse. Ora ti mostro quali sono, così non ti ritrovi con nomi inaspettati.

• Config a livello di sistema (--system) si applica a tutti gli utenti della macchina. Nella pratica è raro e la maggior parte degli sviluppatori non lo tocca mai.

• Config globale (--global) si applica al tuo account utente del sistema operativo e copre tutti i repository.

• Config locale (--local) vive nel file .git/config di un singolo repository e riguarda solo quel repo.

Git usa regole di precedenza per decidere quale valore ha la meglio.

Le impostazioni locali sovrascrivono quelle globali, che a loro volta sovrascrivono quelle di sistema. Se imposti user.name a tutti e tre i livelli, Git userà il valore locale quando sei dentro quel repo e ignorerà gli altri.

Mettiamo che tu abbia:

• Sistema: user.name = "System User"

• Globale: user.name = "Global User"

• Locale (dentro uno specifico repo): user.name = "Local User"

Quando fai commit dentro quel repo, Git usa "Local User" perché il livello locale è il più specifico. Fuori da quel repo, Git torna a "Global User" dalla configurazione globale.

Puoi vedere tutti i valori di config e da dove provengono:

git config --list
git config --list --show-origin

Il flag --show-origin stampa il percorso del file accanto a ciascuna impostazione. Così fai debug del "perché Git sta usando questo nome?" — vedrai esattamente quale file di config sta impostando il valore.

Questi file di config si trovano in posizioni prevedibili: ~/.gitconfig per le impostazioni globali e .git/config dentro ogni repository per le impostazioni locali. La config di sistema di solito è in /etc/gitconfig su Linux e macOS.

Quando esegui git config --global user.name "Your Name", Git scrive in ~/.gitconfig e quel valore diventa il tuo default per ogni repo, a meno che non lo sovrascrivi in locale.

Come controllare il tuo Git username attuale

Devi sapere quale nome Git apporrà sul prossimo commit. Ecco un paio di comandi da eseguire.

Comandi rapidi per visualizzare user.name

Ecco i comandi che mostrano il tuo Git username:

# Show the active user.name for the current repo (or global if outside a repo)
git config user.name

# Show specifically the global username
git config --global user.name

# Show everything and scan for user.name and user.email
git config --list

Il primo comando — git config user.name — è quello che vuoi la maggior parte delle volte. Mostra il valore che Git userà davvero in quel repo. Se sei in un repo con un override locale, vedrai il valore locale. Altrimenti vedrai il fallback globale.

Se vuoi filtrare l’elenco completo della config, passalo a grep:

git config --list | grep user.name

git config --list | grep user.name

Funziona su Linux e macOS. Su Windows, usa findstr invece di grep.

Capire cosa stai vedendo

Se git config user.name stampa un valore dentro un repo, è quello che Git userà quando fai commit lì.

Ma git config --global user.name potrebbe mostrare qualcosa di diverso. Git ignora il valore globale se esiste un’impostazione locale. Qui spesso ci si confonde: si cambia la config globale e ci si chiede perché i commit mostrino ancora il vecchio nome.

Usa git config --list --show-origin per fare debug:

git config --list --show-origin

git config --list --show-origin

Questo comando stampa il percorso del file da cui proviene ogni impostazione: - gitconfig per la locale, ~/.gitconfig per la globale, o /etc/gitconfig per il sistema. Cerca user.name e vedrai esattamente quale file di config prevale.

Step-by-step: impostare il tuo Git username

La maggior parte degli sviluppatori imposta il Git username una volta e poi se ne dimentica. Tuttavia, puoi personalizzarlo per progetto quando serve.

Impostare il tuo Git username globalmente

Questa è la configurazione una tantum che fai su una nuova macchina.

1. Apri Terminale (macOS/Linux) o Git Bash (Windows)
2. Esegui il comando di config con il tuo nome:

git config --global user.name "Your Name"

3. Verifica che abbia funzionato:

git config --global user.name

Git ora userà questo nome per ogni commit in ogni repository sulla tua macchina, a meno che tu non lo sovrascriva localmente.

Già che ci sei, imposta anche la tua email:

git config --global user.email "your.email@example.com"

Entrambi i valori devono essere impostati affinché i commit funzionino correttamente e si colleghino al tuo account GitHub o GitLab.

git config --global user.email "your.email@example.com"

Se ti servono nomi diversi per progetti diversi, ad esempio il nome reale per i repo di lavoro e uno pseudonimo per l’open-source.

Ecco come sovrascrivere l’impostazione globale per un singolo repo:

1. Entra nel repository:

cd /path/to/your/repo

2. Imposta lo username locale:

git config user.name "Project-Specific Name"

3. Verifica che Git lo userà:

git config user.name

Questo valore vive in .git/config dentro quel repository e sovrascrive il tuo user.name globale solo per quel repo. Gli altri repo sulla tua macchina non sono influenzati.

Suggerimento avanzato: username diversi per cartelle diverse con includeIf

Se lavori su più progetti con identità diverse — ad esempio, tutti i repo sotto ~/work/ usano il tuo nome di lavoro e tutto ciò che sta sotto ~/personal/ usa uno pseudonimo — puoi automatizzare con includeIf.

Aggiungi questo al tuo ~/.gitconfig:

[includeIf "gitdir:~/work/"]
    path = ~/.gitconfig-work

[includeIf "gitdir:~/personal/"]
    path = ~/.gitconfig-personal

Poi crea file di config separati come ~/.gitconfig-work:

[user]
    name = "Work Name"
    email = "work@company.com"

E ~/.gitconfig-personal:

[user]
    name = "Personal Handle"
    email = "personal@email.com"

Git sceglie automaticamente l’identità giusta in base a dove vive il repo. Non serve passare manualmente da una all’altra.

Scenario comuni e buone pratiche

Ecco come gestire le situazioni più comuni legate allo username Git senza creare confusione.

Tenere separate identità di lavoro e personali

Imposta il tuo nome personale globalmente, poi sovrascrivilo per i progetti di lavoro. Così i repo personali usano di default la tua identità preferita e i repo di lavoro usano il tuo nome professionale.

L’approccio più pulito è usare includeIf per cambiare identità automaticamente in base alla cartella:

# In ~/.gitconfig
[user]
    name = "Personal Name"
    email = "personal@email.com"

[includeIf "gitdir:~/work/"]
    path = ~/.gitconfig-work

Poi crea ~/.gitconfig-work con la tua identità di lavoro. Ogni repo sotto ~/work/ riceverà automaticamente il nome di lavoro. L’ho spiegato nella sezione precedente.

Puoi anche impostare la config locale per repo se hai solo un paio di progetti di lavoro, ma includeIf scala meglio quando gestisci più identità su molti repo.

Usare uno pseudonimo o un handle

A Git non interessa se usi il tuo nome legale.

Puoi impostare user.name su un handle, su nome e iniziale del cognome, o su ciò che preferisci per la privacy. È comune nell’open-source, dove i contributor vogliono un po’ di anonimato. Scegli qualcosa che aiuti il tuo team a identificare i tuoi commit.

Identità di team o bot

I commit automatici dovrebbero usare nomi descrittivi come "CI Bot" o "Deploy Script" così risaltano nella cronologia.

git config user.name "CI Bot"
git config user.email "ci@company.com"

Così è ovvio quali commit provengono dall’automazione e quali dagli sviluppatori quando scorri git log o rivedi le annotazioni blame.

Ricorda di allineare nome ed email sulle piattaforme di hosting

GitHub e GitLab associano i commit al tuo account usando l’indirizzo email, non il nome. Se l’email del commit corrisponde a un’email presente sul tuo account GitHub, GitHub collega il commit al tuo profilo e mostra il tuo avatar.

Il valore user.name compare come testo nell’interfaccia — nelle pull request, nelle viste blame e nella cronologia commit. Impostalo in modo chiaro così i compagni sanno chi ha fatto la modifica.

Risoluzione dei problemi con git config username

Se qualcosa relativo allo username di Git non funziona, probabilmente qui troverai causa e soluzione.

Git dice "please tell me who you are" o non riesce ad auto-rilevare la tua identità

Vedrai un errore del genere quando provi a fare commit:

*** Please tell me who you are.

Run
  git config --global user.email "you@example.com"
  git config --global user.name "Your Name"

Questo significa che Git non ha impostato la tua user.email e a volte manca anche user.name. Risolvi impostando entrambi globalmente:

git config --global user.name "Your Name"
git config --global user.email "your.email@example.com"

Dopo, i commit funzioneranno.

I miei commit mostrano il nome sbagliato su GitHub o GitLab

Controlla quale nome Git sta effettivamente usando in quel repo:

git config user.name

Se mostra il nome sbagliato, potrebbe esserci un override locale. Correggilo con questo comando:

git config user.name "Correct Name"

I nuovi commit useranno il nome corretto, ma i commit vecchi che hai già pushato manterranno il nome autore originale.

Ho aggiornato il mio Git username, ma i commit vecchi mostrano ancora il nome precedente

I metadati dei commit vengono fissati nella cronologia di Git quando crei il commit.

Cambiare user.name influisce solo sui commit futuri. Se devi cambiare i nomi autore sui commit vecchi, dovresti riscrivere la cronologia usando git rebase --interactive o git filter-repo. È avanzato, rischioso su branch condivise e di solito non ne vale la pena.

Continuo a confondere le identità passando tra progetti

Usa includeIf per cambiare identità automaticamente in base a dove vive il repo.

Aggiungi questo a ~/.gitconfig:

[includeIf "gitdir:~/company/"]
    path = ~/.gitconfig-company

[includeIf "gitdir:~/personal/"]
    path = ~/.gitconfig-personal

Poi crea ~/.gitconfig-company con la tua identità di lavoro e ~/.gitconfig-personal con la tua identità personale. Git sceglie automaticamente quella giusta in base alla posizione del repo — niente più commit col nome sbagliato.

Conclusione

In sintesi, impostare correttamente il tuo Git username mantiene pulita la cronologia dei commit e rende più semplice collaborare.

Quando ogni commit mostra l’autore corretto, il team può tracciare chi ha fatto le modifiche. Le code review scorrono più veloci, le annotazioni blame hanno senso e la cronologia del progetto resta leggibile. Conta ancora di più man mano che i progetti crescono e aumentano i contributor.

Se passi tra progetti di lavoro e personali, o usi nomi diversi per clienti diversi, non devi cambiare manualmente la config ogni volta. Configura una volta con override locali o includeIf e Git sceglierà quello giusto ogni volta.

Se vuoi andare oltre le basi ed eliminare ogni dubbio su Git e GitHub, queste risorse di DataCamp sono il passo successivo ideale:

• Intermediate Git
• GitHub Concepts
• GitHub Foundations