Git Switch Branch: una guida con esempi pratici

Scoprire i nomi dei branch esistenti

Se vogliamo elencare i branch disponibili, usiamo il comando git branch. Il branch corrente verrà mostrato con un asterisco accanto. Per esempio, se abbiamo tre branch locali chiamati main, feature-x e bug-z, e siamo attualmente sul branch main, l'output sarebbe:

* main
feature-x
bug-z

Passare a un branch remoto

Il comando precedente ci permette di passare a un branch che abbiamo già in locale. Per passare a un branch dal repository remoto, dobbiamo crearne una versione locale usando il comando seguente:

git switch -c <local-branch-name> origin/<remote-branch-name>

Qui, <local-branch-name> è il nome che vogliamo dare al branch in locale, mentre <remote-branch-name> è il nome del branch remoto. In generale, conviene usare lo stesso nome per evitare confusione. Diciamo che non abbiamo il branch feature-x in locale. Possiamo allora crearne una versione locale e passarci, così:

git switch -c feature-x origin/feature-x

Usando lo stesso nome, Git fornisce una scorciatoia con l'opzione --track. Quindi il comando sopra è equivalente a:

git switch --track origin/feature-x

Per elencare i branch remoti, possiamo usare il comando git branch -r.

Il repository locale non tiene traccia automaticamente dei branch remoti. Pertanto, prima di elencare o passare a un branch remoto, è importante aggiornare il repository locale usando git fetch.

Creare un nuovo branch e passarci

Vogliamo creare un branch completamente nuovo per iniziare a lavorare su una nuova feature. In questo caso, possiamo usare il flag -c:

git switch -c <new-branch-name>

Sostituiamo <new-branch-name con il nome del branch. Per esempio, per creare un branch chiamato feature-y procediamo così:

git switch -c feature-y

Tornare al branch precedente

Spesso, dopo aver cambiato branch per fare qualche lavoro, vogliamo tornare al branch su cui stavamo lavorando in precedenza. Git fornisce una scorciatoia con il comando:

git switch -

Git switch vs. Git checkout

Il comando git checkout esiste in Git fin dagli inizi. Prima dell'introduzione di git switch nel 2019, git checkout era il comando usato per passare tra i branch. Tuttavia, la portata di git checkout va oltre il semplice spostamento tra branch. Ecco un riepilogo delle differenze:

• git switch: ha lo scopo di offrire un modo più intuitivo per cambiare e creare nuovi branch. Mira a semplificare l'insieme dei comandi e ridurre la confusione.
• git checkout: un comando più versatile che può essere usato per cambiare branch, ma anche per estrarre file e ripristinare contenuti da diversi commit o branch.

Il design di git switch rende più difficile sovrascrivere accidentalmente le modifiche. Ha una sintassi più esplicita per il cambio di branch e la creazione di nuovi branch.

Poiché git checkout fa più cose (cambio di branch, ripristino file, ecc.), c'è una maggiore probabilità di commettere errori durante il suo utilizzo.

Git switch: errori comuni

Gestendo i branch, potresti imbatterti in alcuni problemi comuni. Uno è tentare di creare un branch che esiste già in locale. Un altro errore frequente si verifica quando si prova a cambiare branch con modifiche non confermate. Iniziamo spiegando il primo.

Il branch esiste già in locale

Ogni branch locale deve avere un nome univoco. Puoi usare git switch per creare branch locali in due modi:

1. Per tracciare un branch remoto:

git switch --track origin/<branch-name>

2. Per creare un nuovo branch locale:

git switch -c <branch-name>

In entrambi i casi, se esiste già un branch locale chiamato <branch-name>, Git restituirà un errore che dice:

fatal: a branch named '<branch-name>' already exists

In questo caso, possiamo passare al branch senza crearlo usando git switch <branch-name>.

Il branch corrente ha modifiche non confermate

Git non ci permetterà di cambiare branch se quello corrente ha modifiche non confermate che verrebbero sovrascritte dal cambio. In questo caso, Git restituirà un errore che dice:

Please commit your changes or stash them before you switch branches.

Come indica il messaggio, per superare questa situazione dobbiamo prima fare commit delle modifiche o metterle in stash. Se le modifiche sono pronte per essere inviate al repository dovremmo eseguirne il commit usando:

git commit -m "Commit message"

Se vogliamo mantenere le modifiche ma non siamo pronti a fare commit, possiamo salvarle temporaneamente usando il comando git stash:

git stash

Se mettiamo in stash le modifiche prima di cambiare branch e vogliamo riapplicarle quando torniamo al branch originale, possiamo usare il comando git stash pop.

In alternativa, possiamo anche decidere di scartare le modifiche usando il flag --discard-changes:

git switch --discard-changes <branch-name>

Fai attenzione prima di usare quest'ultima opzione perché le modifiche verranno eliminate in modo permanente.

Uso avanzato di Git switch

Quando devi creare branch da punti specifici della storia del progetto o gestire scenari particolari, git switch offre funzionalità avanzate per soddisfare queste esigenze.

Diramarsi da un punto specifico

Per impostazione predefinita, quando crei un branch con git switch, lo stato iniziale del nuovo branch sarà il HEAD del branch su cui ci troviamo.

Immagina di voler iniziare un nuovo branch da un commit precedente specifico. Ogni commit è identificato da un <hash> univoco, che possiamo usare con il comando git switch per creare un nuovo branch da quel commit. Ecco come fare:

switch -c feature-y <hash>

Sostituisci <hash> con l'hash del commit effettivo.

Passare a una detached head

Se vogliamo esplorare o sperimentare con un commit specifico senza toccare il branch corrente o crearne uno nuovo, possiamo usare una detached head con il comando:

git switch --detach <hash>

Distaccando la head, possiamo ispezionare in sicurezza lo stato del repository a un commit specifico, eseguire test o apportare modifiche temporanee senza il rischio che tali modifiche vengano accidentalmente inviate al branch di lavoro corrente. I casi d'uso più comuni includono:

• Visualizzare uno stato precedente: se vogliamo ispezionare o testare un commit più vecchio senza modificare il branch corrente, possiamo passare a quel commit in stato detached.
• Modifiche temporanee: se vogliamo sperimentare modifiche senza toccare alcun branch, possiamo farlo in stato di detached head. Nota che eventuali nuovi commit creati in questo stato non apparterranno a nessun branch e potremmo dover creare un nuovo branch se vogliamo conservarli.
• Scopi di build/test: a volte, dobbiamo fare build o test del software a un commit specifico. Passare a uno stato di HEAD staccata su quel commit ci permette di farlo senza alcun impatto sulla struttura dei branch del repository.

Forzare un cambio

Abbiamo visto che Git non ci consente di cambiare branch se ci sono modifiche non confermate che potrebbero andare in conflitto con il branch di destinazione. Se siamo sicuri di voler scartare quelle modifiche e procedere con il cambio, possiamo forzarlo usando l'opzione -f, così:

git switch -f <branch-name>

Ci sono avvertenze importanti da considerare. 

• Qualsiasi modifica non confermata andrà persa senza preavviso, con il rischio di perdita di lavoro se tali modifiche non sono state salvate altrove. 
• Usare -f indiscriminatamente può favorire la mancanza di disciplina, incoraggiando gli sviluppatori ad aggirare pratiche corrette di versionamento come lo stash o il commit delle modifiche WIP (work in progress). Questo può portare a una cronologia del repository caotica e complicare la collaborazione. Pertanto, sebbene git switch -f offra velocità e comodità, va usato con giudizio e con chiara consapevolezza dei rischi per evitare possibili svantaggi.

Conclusione

Il comando git switch rende più semplice cambiare e creare branch rispetto al vecchio comando git checkout.

Semplifica il processo e aiuta a ridurre gli errori, rendendo più facile per gli sviluppatori gestire la loro codebase.

Questo comando aiuta a evitare problemi comuni, come sovrascrivere accidentalmente modifiche o confondere le diverse funzioni di git checkout.

Adottarlo può rendere la navigazione tra i branch Git più intuitiva e migliorare la collaborazione all'interno dei team di sviluppo.