Branching in Git: Creare, Unire, Eliminare e Gestire i Conflitti — Guida Operativa

Hai mai lavorato su un progetto condiviso, fatto modifiche, e poi scoperto che qualcuno ha sovrascritto il tuo lavoro? Se sei qui, conosci già quella sensazione. Il branching in Git è la soluzione: ti permette di isolare modifiche, sperimentare senza paura, e lavorare in parallelo senza pestarsi i piedi. Noi, di Meteora Web, lo usiamo ogni giorno per gestire decine di progetti — da siti WordPress a piattaforme Laravel. In questa guida impari a creare, unire, eliminare branch e gestire i conflitti. Niente teoria astratta: comandi, esempi reali, e una procedura che puoi applicare subito.

Cos'è un branch e perché ti serve

Un branch in Git è un puntatore mobile a uno specifico commit. Immagina un albero: il tronco è il branch principale (di solito main o master), i rami laterali sono branch per feature, bugfix o esperimenti. Lavorare su un branch separato significa che le tue modifiche non toccano il lavoro degli altri finché non decidi di unirle. Questo è essenziale in team, ma anche da solista: potresti avere una versione stabile (main) e una su cui stai testando una nuova funzionalità rischiosa. Se tutto va male, cancelli il branch e nessun danno.

Il vantaggio concreto: zero sovrascritture accidentali, possibilità di lavorare su più fronti contemporaneamente, e una storia chiara di cosa è stato fatto e quando. Noi lo applichiamo anche al codice dei nostri clienti: ogni modifica ha il suo branch, ogni merge è tracciato. Se qualcosa si rompe, sai esattamente quale ramo ha causato il problema.

Visualizzare i branch esistenti

Prima di creare, devi sapere dove ti trovi. Usa:

git branch

Mostra tutti i branch locali. Il branch attivo ha un asterisco (* main). Per vedere anche quelli remoti:

git branch -a

Creare un branch

Creare un branch è immediato. Il comando base:

git branch nome-branch

Crea un nuovo branch che punta allo stesso commit dove ti trovi ora. Per spostarti subito su di esso, unisci i due comandi:

git checkout -b nome-branch

Oppure, con Git 2.23+, la via moderna:

git switch -c nome-branch

Esempio pratico: devi aggiungere una sezione "Contatti" al tuo sito. Crei un branch feature/contatti e inizi a lavorare. Intanto il main rimane pulito, deployabile.

Una regola che seguiamo noi: i nomi dei branch devono essere descrittivi. Usa feature/, bugfix/, hotfix/ come prefissi. Evita nomi generici come modifiche o temp — dopo una settimana non ricorderai cosa contenevano.

Scegliere da dove partire

Se vuoi creare un branch partendo da un commit specifico (non dall'ultimo), passa l'identificativo del commit:

git branch nome-branch <commit-hash>

Utile se devi fare un hotfix su una versione precedente del codice già in produzione.

Lavorare su un branch

Ora che sei sul branch feature/contatti, fai le tue modifiche, aggiungi, committa. Git registra i commit su quel branch, non sul main. Puoi alternare tra branch con:

git switch main

Git aggiorna i file nella directory di lavoro per riflettere lo stato del branch scelto. Attenzione: se hai modifiche non committate, Git potrebbe bloccarti. O committa o usa git stash per metterle da parte temporaneamente.

Unire un branch (merge)

Quando la funzionalità è pronta, vuoi portare le modifiche nel main. Ci sono due scenari principali.

Merge con fast-forward

Succede quando il branch main non ha avuto nuovi commit dopo la creazione del tuo branch. Git può semplicemente spostare in avanti il puntatore di main. Comando:

git switch main
git merge nome-branch

Se non ci sono divergenze, vedrai un messaggio "Fast-forward". La storia è lineare.

Merge con commit di merge (three-way merge)

Se il main ha ricevuto altri commit mentre lavoravi sul feature branch, Git deve fare un merge a tre vie: combina le modifiche del main, del tuo branch e l'antenato comune. Viene creato un commit di merge con due genitori. Comando identico, ma Git crea automaticamente il merge commit (a meno che non usi --no-ff per forzarlo o --ff-only per fallire se non è possibile).

Noi, di Meteora Web, preferiamo fare sempre git merge --no-ff nome-branch sui progetti condivisi. Anche se è possibile un fast-forward, creiamo un commit di merge esplicito. Questo mantiene traccia che quel gruppo di commit apparteneva a una feature specifica. Sfogare la storia diventa più chiaro.

Risolvere i conflitti di merge

I conflitti capitano. Git non può decidere da solo quale modifica tenere. Succede quando due branch hanno modificato le stesse righe dello stesso file. Il messaggio di errore è chiaro: "Automatic merge failed; fix conflicts and then commit the result."

Identificare i conflitti

Usa git status per vedere i file in conflitto. Dentro al file troverai marcatori come:

<<<<<<< HEAD
codice del branch attuale (main)
=======
codice del branch che stai unendo (feature/contatti)
>>>>>>> nome-branch

HEAD è il tuo ramo attuale, l'altra sezione è quella in arrivo.

Risolvere manualmente

Apri il file con un editor di codice. Decidi quale versione tenere o combina entrambe. Elimina i marcatori di conflitto. Salva. Poi:

git add file-risolto
git commit

Git ti mostrerà un messaggio precompilato che puoi modificare. Fatto — il merge è completato.

Strumenti grafici: Se preferisci un'interfaccia visiva, usa git mergetool che apre strumenti come Meld, Beyond Compare o il tuo editor preferito con supporto diff3.

Strategia per evitare conflitti

• Aggiorna spesso il tuo branch: fai git merge main sul tuo feature branch regolarmente. Così risolvi i conflitti in piccolo, non tutto insieme alla fine.
• Comunica nel team: se sai che qualcuno sta modificando lo stesso file, coordinatevi.
• Dividi il lavoro in branch piccoli: un branch che dura settimane è una bomba a orologeria. Meglio feature brevi e merge frequenti.

Eliminare un branch

Dopo il merge, puoi pulire il branch locale:

git branch -d nome-branch

Git ti impedirà di eliminare un branch che non è stato unito (perdita di modifiche). Se sei sicuro di volerlo buttare via, forza con -D (maiuscolo).

Per eliminare un branch remoto (es. su GitHub):

git push origin --delete nome-branch

O con sintassi abbreviata:

git push origin :nome-branch

Attenzione: elimina solo il ramo remoto. Il locale resta, quindi cancellalo anche lì.

Vedere branch remoti orfani

Dopo aver eliminato molti branch, il tuo remoto potrebbe avere rami vecchi. Per sincronizzare:

git remote prune origin

In sintesi — cosa fare adesso

1. Apri il terminale nella directory del tuo progetto Git e digita git branch per vedere dove sei.
2. Crea un branch di prova con git checkout -b prova-branch, fai una modifica, committa e torna al main (git switch main).
3. Unisci il branch di prova con git merge prova-branch. Se non ci sono conflitti, hai fatto pratica.
4. Simula un conflitto: crea un altro branch, modifica le stesse righe del file, cerca di unire e risolvi i marcatori a mano.
5. Pulisci: elimina il branch di prova (git branch -d prova-branch).

Il branching è un superpotere. Usalo e non tornerai più indietro. Se hai un progetto legacy senza branch, inizia subito: crea un ramo per la prossima modifica. La tua tranquillità futura vale la mezza riga di comando.