Elencare i branch in Git: guida pratica

Se ti è mai capitato di lavorare su più funzionalità contemporaneamente, questa situazione potrebbe suonarti familiare: esegui un comando Git e ora non sei più sicuro dove si trovi davvero il lavoro che hai fatto la settimana scorsa.

Questo problema diventa più comune man mano che i progetti crescono. All’inizio, un repository potrebbe avere solo un branch main. Col tempo, però, i team creano branch per nuove funzionalità, correzioni di bug, esperimenti, release e hotfix di emergenza. 

Qui è dove elencare i branch in Git diventa essenziale. Aiuta a rispondere a domande pratiche:

• Su quale branch sto lavorando attualmente?
• Quali altri branch esistono sulla mia macchina?
• Quali branch esistono sul repository remoto?

In questa guida, vedremo le basi su come elencare i branch in Git, come farlo e come risolvere i problemi più comuni.

Se Git è completamente nuovo per te, ti consiglio di seguire il nostro corso Introduction to Git per prendere confidenza prima di affrontare argomenti più dettagliati sulla gestione dei branch.

Capire i branch di Git

Prima di iniziare a elencarli, vediamo cosa sono i branch in Git. 

Un malinteso comune è che i branch Git siano cartelle separate o copie complete del codebase; in realtà, un branch Git è solo un puntatore leggero a uno specifico commit.

Puoi pensarli come una linea temporale parallela in cui puoi sviluppare funzionalità o fare esperimenti in isolamento senza influenzare il codice principale stabile. Questa architettura rende la creazione e il merge dei branch estremamente veloci ed efficienti.

Fonte: Git

Git tiene traccia della tua posizione corrente in queste linee temporali usando un riferimento speciale chiamato HEAD, che punta sempre al branch su cui stai lavorando in questo momento. Poiché i branch sono solo puntatori, cambiare contesto è istantaneo e non richiede di spostare file pesanti.

Per maggiori dettagli, dai un’occhiata al nostro tutorial sui branch Git o consulta il nostro Git cheat sheet.

Come elencare i branch locali in Git

Con queste basi concettuali, vediamo come elencare i branch locali nel tuo repository.

Un branch locale è un branch che esiste sul tuo computer. Vive nella cartella .git del tuo repository e rappresenta un puntatore mobile a una serie di commit. Puoi passare a un branch locale, fare modifiche e creare nuovi commit su di esso.

Può essere utile pensare ai branch locali in questo modo:

• Appartengono alla tua copia del repository
• Avanzano quando effettui nuovi commit
• Non si aggiornano automaticamente quando altre persone fanno push del codice

Usare git branch

Il comando più comune e fondamentale per elencare i branch locali è piuttosto semplice:

git branchOfferto da

Quando esegui questo comando senza opzioni aggiuntive, Git mostra tutti i branch locali.

Cose importanti da ricordare su git branch:

• Mostra solo i branch locali, non quelli remoti
• Non contatta internet
• Non modifica file, commit o la cronologia dei branch

Poiché è sicuro e veloce, molti sviluppatori eseguono git branch per abitudine prima di iniziare un nuovo lavoro o cambiare contesto.

Capire l’output

Ecco un esempio di ciò che potrebbe mostrare git branch:

 bugfix/login-timeout
  feature/payment-refactor
* mainOfferto da

Anche se questo output sembra semplice, ci sono alcuni dettagli importanti nascosti.

Primo, l’asterisco (*) indica il branch attualmente selezionato. È il branch a cui è legata ora la tua working directory. Qualsiasi nuovo commit che crei andrà su questo branch.

Secondo, Git di solito evidenzia il branch corrente in verde. È solo un aiuto visivo del terminale e non cambia il comportamento di Git.

Terzo, nota cosa non viene mostrato:

• Nessuna data dei commit
• Nessun nome autore
• Nessuna informazione sui remoti

È intenzionale. Git mantiene l’output predefinito breve, così è facile da scansionare e combinare con altri comandi.

Consiglio per principianti: Se il terminale sembra "bloccato" dopo l’esecuzione di un comando Git, prova a premere q. Git spesso usa un pager per mostrare output lunghi, e questo è il modo normale per uscirne.

Ottenere solo il branch corrente

A volte elencare tutti i branch è superfluo. Potresti voler sapere solo su quale branch ti trovi. Git fornisce un comando dedicato per questo:

git branch --show-currentOfferto da

L’output è solo il nome del branch:

mainOfferto da

Situazioni comuni in cui è utile includono:

• Controllare il branch prima di fare push del codice
• Registrare il nome del branch negli script
• Usare il nome del branch in automazioni o pipeline CI

Se Git è in stato di HEAD staccata (detached), questo comando non restituisce nulla. Anche se può sembrare strano, è utile quando scrivi script che devono rilevare se un branch è selezionato.

Errore comune: Alcuni utenti pensano che Git sia "rotto" quando non appare alcun nome di branch. Nella maggior parte dei casi significa semplicemente che non sei su un branch, ma su uno specifico commit.

Come elencare i branch remoti e tutti i branch in Git

Elencare i branch remoti o anche tutti i branch in Git funziona in modo molto simile all’elenco di quelli locali.

Elencare i branch remoti in Git

I repository remoti, come quelli su GitHub o GitLab, hanno i propri branch. Per vederli, aggiungi il flag -r:

git branch -rOfferto da

  origin/HEAD -> origin/main
  origin/bugfix/login-timeout
  origin/feature/payment-refactor
  origin/mainOfferto da

Questo output può confondere all’inizio, quindi analizziamolo.

Quello che vedi sono branch di tracciamento remoti. Sono riferimenti locali che Git usa per ricordare l’ultimo stato conosciuto del repository remoto.

Punti chiave da capire:

• Questi branch sono memorizzati in locale
• Si aggiornano solo quando esegui fetch
• Non si muovono automaticamente

Consiglio per principianti: Pensa ai branch di tracciamento remoti come al quaderno di Git. Git annota com’era il remoto l’ultima volta che hai controllato, ma non aggiornerà quel quaderno a meno che tu non faccia fetch esplicitamente.

Elencare tutti i branch in Git

Per vedere insieme sia i branch locali che quelli di tracciamento remoti, usa il flag -a:

git branch -aOfferto da

* main
  feature/payment-refactor
  remotes/origin/bugfix/login-timeout
  remotes/origin/mainOfferto da

Questa vista combinata ti aiuta a capire come i tuoi branch locali si relazionano a quelli remoti.

Pattern di denominazione a cui prestare attenzione:

• I branch locali appaiono come nomi semplici come main

• I branch di tracciamento remoti appaiono sotto remotes/origin/

Questa vista è particolarmente utile quando decidi se creare un nuovo branch locale che tracci un branch remoto esistente. Se devi clonare un repository e lavorare su uno specifico branch, consulta la nostra guida su come clonare un branch specifico in Git.

Fai sempre fetch prima

Se un collega fa push di un nuovo branch e tu non riesci a vederlo, la ragione più comune è che la tua cache locale è obsoleta. 

La soluzione è fare fetch:

git fetchOfferto da

Cosa fa git fetch:

• Scarica le informazioni più recenti sui branch dal remoto
• Aggiorna i tuoi branch di tracciamento remoti
• Lascia invariati i tuoi file di lavoro

Questo comando è sicuro da eseguire in qualsiasi momento. Non fa merge del codice e non sovrascrive il tuo lavoro. Molti team trattano git fetch come un passaggio di routine prima di ispezionare i branch.

Errore comune: I principianti spesso confondono git fetch con git pull. Fetch aggiorna solo le informazioni sui branch, mentre pull unisce anche le modifiche nel tuo branch corrente.

Come ottenere più dettagli nell’elenco dei branch Git

A volte i nomi dei branch non bastano. Se vuoi vedere dettagli aggiuntivi, ci sono alcuni flag utili che possono aiutarti.

Vedere gli ultimi commit

Per vedere cosa contiene effettivamente ciascun branch, usa:

git branch -vOfferto da

L’output potrebbe essere così:

* main   a1b2c3d Fix typo in README
  feature/payment-refactor e4f5g6h Refactor payment serviceOfferto da

Come vedi, il flag -v aggiunge contesto importante:

• L’hash breve del commit mostra dove punta attualmente il branch
• Il messaggio di commit suggerisce lo scopo del branch

È uno dei modi più semplici per capire a cosa serve un branch senza farne il checkout.

Consiglio per principianti: Se non sei sicuro che un branch sia sicuro da eliminare, controllare il suo ultimo messaggio di commit è un buon primo indizio. Per una guida completa alla rimozione dei branch, vedi il nostro tutorial su come eliminare i branch Git.

Verificare le connessioni upstream

I branch locali spesso tracciano un branch remoto corrispondente. Per vedere questa relazione, esegui:

git branch -vvOfferto da

* main   a1b2c3d [origin/main] Fix typo in README
  feature/payment-refactor e4f5g6h [origin/feature/payment-refactor] Refactor payment serviceOfferto da

Questo output ti dice:

• A quale branch remoto è collegato il tuo branch locale

• Da dove git pull preleverà

• Dove git push invierà

Se un branch non ha upstream, non mostrerà nulla tra parentesi. Spesso questo spiega gli errori di push o pull.

Errore comune: Provare a eseguire git pull su un branch senza upstream di solito fallirà. In quel caso, devi prima impostare un branch upstream o fare il primo push del branch.

Ordinare i branch per data o versione

Per trovare i branch attivi di recente, puoi ordinarli per data del commit:

git branch --sort=-committerdateOfferto da

Questo mette in cima i branch aggiornati più di recente e in fondo quelli più vecchi.

Per repository con branch versionati, è più utile un ordinamento semantico:

git branch --sort=v:refnameOfferto da

Questo rispetta i numeri di versione ed evita l’ordine alfabetico fuorviante.

Come filtrare l’elenco dei branch in Git

Se stai cercando un branch specifico, filtrare può essere molto utile. Ti mostrerò come farlo usando alcuni flag importanti.

Cercare per pattern nel nome

Soprattutto in repository grandi, filtrare per nome può farti risparmiare molto tempo nel trovare il branch giusto. Puoi filtrare per nome usando il flag --list insieme al termine di ricerca:

git branch --list 'feature/*'Offerto da

Nota come * sia usato come wildcard: il risultato qui mostra solo i branch che corrispondono al pattern, quindi quelli che iniziano con feature. I team usano spesso prefissi come feature/, bugfix/ o hotfix/ per mantenere ordine. Pensali come cartelle per i tuoi branch.

Trovare branch uniti vs. non uniti

Due filtri molto importanti sono:

git branch --merged
git branch --no-mergedOfferto da

Questi comandi confrontano gli altri branch con il tuo branch corrente.

• --merged mostra i branch il cui lavoro è già incluso (scopri di più su Git merge)

• --no-merged mostra i branch che contengono ancora commit unici

Promemoria di sicurezza: Controlla sempre di trovarti sul branch base corretto (spesso main o develop) prima di usare --merged. I risultati dipendono dal tuo branch corrente.

Trovare quale branch contiene un commit

Se conosci un hash di commit e vuoi trovare dove esiste, usa questo comando:

git branch --contains <commit-hash>Offerto da

È utile per tracciare bug o verificare che una correzione sia stata unita.

Per esempio, quando un collega ti dice: "Ho trovato un bug in questo commit; quali branch ne sono interessati?" Puoi usare questo comando per individuare l’esatta posizione del bug.

Combinare i filtri per workflow avanzati

I filtri che ti ho mostrato possono essere combinati per restringere ulteriormente i risultati. Vediamo un esempio:

git branch --list 'feature/*' --no-mergedOfferto da

Il risultato di questo comando mostra rapidamente tutti i branch feature/ non ancora uniti e aiuta il team a restare organizzato.

Risoluzione dei problemi comuni

Se incontri problemi, niente panico; i casi più comuni sono piuttosto facili da risolvere.

Branch remoti mancanti

Se non riesci a vedere un branch che qualcun altro ha pubblicato, la ragione più probabile è che ti sei semplicemente dimenticato di fare fetch. Per procedere al troubleshooting:

1. Esegui git fetch

2. Poi elenca di nuovo i branch

Se il problema era il mancato fetch, questa rapida correzione aggiorna immediatamente la tua vista locale.

Lo stato di HEAD staccata

A volte, l’output di git branch appare così:

* (HEAD detached at a1b2c3d)Offerto da

Questo significa che non sei su un branch. Stai visualizzando direttamente uno specifico commit.

Essere in stato di HEAD staccata non è pericoloso di per sé, ma eventuali nuovi commit possono essere difficili da trovare più tardi, a meno che tu non crei un branch.

Per tornare al lavoro normale, passa a un branch esistente:

git checkout <branch-name>Offerto da

Alternativa moderna: Dalla versione 2.23+ di Git, puoi usare git switch <branch-name>, un comando più pulito e sicuro progettato specificamente per cambiare branch.

Puoi anche creare un nuovo branch dalla tua posizione attuale usando il flag -b:

git checkout -b <new-branch-name>Offerto da

I branch compaiono ancora dopo l’eliminazione

Se i branch remoti compaiono ancora dopo l’eliminazione sul server, puoi ripulire il loro riferimento locale con il seguente comando:

git remote prune originOfferto da

Questo elimina i riferimenti obsoleti e mantiene ordinato il tuo repository.

Consiglio pro: In alternativa, puoi usare git fetch --prune ogni volta che fai fetch, così il repo viene aggiornato e ripulito in un solo passaggio.

Conclusione

Elencare i branch in Git è una competenza chiave che ti aiuta a capire il tuo repository. I comandi e i flag trattati in questo tutorial ti aiuteranno a evitare errori e a collaborare con sicurezza.

Quando inizi un nuovo progetto, di solito vale la pena pensare a che tipo di struttura dei branch ti servirà. Per qualche consiglio, dai un’occhiata a questa guida sulle strategie di branching in Git.

Pronto ad andare oltre le basi? Il percorso di competenze Git Fundamentals offre i concetti e l’esperienza pratica necessari per passare da principiante a pro.