I branch consentono di portare avanti in parallelo più linee di lavoro nello stesso progetto, senza intralciarsi. In questo articolo scoprirà che cosa sono e a che cosa servono; imparerà a crearli, a passare dall'uno all'altro, a unire le modifiche e a risolvere con calma i conflitti di merge usando gli strumenti dell'IDE. Sono le basi che Le servono per capire che cosa fa Claude Code quando lavora con il Suo repository in un branch separato.

Gli esempi e le schermate si riferiscono all'IDE JetBrains; i nomi e la posizione delle azioni possono variare a seconda della versione. Per gli esercizi usi un repository di prova separato. Nel progetto di lavoro, segua le regole previste per i branch, i commit e l'invio delle modifiche.

Che cosa sono i branch e a che cosa servono

Un branch dà un nome a una linea separata di commit. Crearlo non copia la cartella del progetto e non salva i file non ancora committati. In una normale directory di lavoro, quando cambia branch Git aggiorna i file in base al branch selezionato; le modifiche non completate possono seguirLa oppure impedire il cambio.

La linea superiore è main, quella inferiore è feature/new-idea. Dopo il merge, main punta a M, che ha due commit genitori: E e D.ABEMCD
La linea superiore è main, quella inferiore è feature/new-idea. Dopo il merge, main punta a M, che ha due commit genitori: E e D.

Dal branch principale main parte un nuovo branch feature/new-idea per una linea di sviluppo separata. Al termine del lavoro, le modifiche vengono unite di nuovo in main.

Immagini di voler rivedere a fondo una parte del progetto o fare un esperimento rischioso. Come farebbe senza Git? Probabilmente copierebbe l'intero progetto in una nuova cartella e lavorerebbe lì. Se il risultato Le piacesse, lo riporterebbe nella cartella principale. Altrimenti, basterebbe eliminare la copia.

L'analogia della copia aiuta a capire le diverse linee di lavoro, ma tecnicamente un branch è un puntatore a un commit. Vediamolo con l'esempio di un libro:

  1. ha un manoscritto completo (è il Suo branch principale main);
  2. vuole scrivere un finale alternativo (crea un nuovo branch, per esempio feature/new-idea);
  3. scrive il nuovo finale senza modificare il testo principale del manoscritto (lavora nel nuovo branch);
  4. se il nuovo finale Le piace di più, sostituisce quello vecchio (fa il merge dei branch - merge);
  5. può eliminare la vecchia bozza con il finale scartato (elimina il branch).
Collegamento con Claude Code

Chieda prima a Claude Code di mostrarLe il branch e le modifiche già presenti. Crei un branch separato solo se è previsto dalle regole del progetto. I commit salvati offrono un punto a cui tornare; eliminare il nome di un branch, da solo, non annulla le modifiche ai file né ripristina lo stato iniziale.

Creare un branch e lavorarci

Passaggio 1. Apra il menu di gestione dei branch.

Nella barra degli strumenti principale, accanto al nome del progetto, trova il widget che mostra il nome del branch corrente (per impostazione predefinita, main). Faccia clic e scelga + New Branch.

Widget dei branch nell'angolo in alto a sinistra

Passaggio 2. Dia un nome al nuovo branch.

È buona pratica dare ai branch un nome che descriva il lavoro da fare. Per esempio, feature/add-usage-examples.

Finestra per creare un nuovo branch

Se durante la creazione seleziona Checkout branch, l'IDE passerà al nuovo branch. Prima di modificare i file, verifichi il nome nel widget.

Passaggio 3. Apporti le modifiche e crei un commit.

Aggiunga al README.md una sezione con esempi d'uso. Esamini le modifiche e crei un commit nel modo consueto: nella cronologia del nuovo branch comparirà uno snapshot salvato.

Commit nel nuovo branch
Collegamento con Claude Code

Quando Claude Code propone di creare un commit, fa proprio questo: salva le modifiche correnti come punto a cui tornare in seguito. Prima di accettare, legga il messaggio del commit: descrive che cosa cambia ed è facile da correggere.

Passare da un branch all'altro

Le modifiche con gli esempi d'uso sono al sicuro nel branch feature/add-usage-examples. Torniamo al branch principale main e vediamo che cosa contiene.

Passaggio 1. Faccia di nuovo clic sul widget con il nome del branch corrente, nell'angolo in alto a sinistra.

Passaggio 2. Nell'elenco Local o Recent scelga il branch main e nel sottomenu che appare faccia clic su Checkout.

Passaggio al branch main

Passaggio 3. Verifichi il risultato.

Dopo il cambio di branch, apra il file README.md. Vedrà che la sezione con gli esempi d'uso non c'è: è rimasta nell'altro branch. In questo modo può lavorare su nuove funzionalità senza toccare la versione stabile nel branch main.

Il file senza le modifiche presenti nell'altro branch

Unire i branch

merge integra la cronologia del branch scelto in quello corrente. Se main non è avanzato da quando è stato creato il branch, è possibile un fast-forward: main si sposta su C3 senza un nuovo commit. Se le linee di sviluppo si sono separate, un merge normale crea un commit con due genitori.

main avanza da C2 a C3 senza un nuovo commitC1C2C3
main avanza da C2 a C3 senza un nuovo commit

Nel caso lineare illustrato, main può avanzare fino a C3. Anche il branch feature/add-usage-examples punta ancora a C3; non è necessario eliminarlo per completare il merge.

Ha terminato il lavoro nel branch feature/add-usage-examples e vuole integrare queste modifiche nel progetto principale.

Passaggio 1. Passi al branch di destinazione.

Si assicuri di trovarsi nel branch IN CUI vuole integrare le modifiche. In questo caso è main.

Passaggio 2. Esegua il merge.

Faccia di nuovo clic sul widget di gestione dei branch. Nell'elenco scelga il branch DA CUI vuole prendere le modifiche (feature/add-usage-examples) e nel sottomenu selezioni Merge 'feature/add-usage-examples' into 'main'.

Esecuzione del merge dei branch

Passaggio 3. Verifichi il risultato.

Ora nel file README.md del branch main trova la nuova sezione con gli esempi. Ha integrato correttamente il Suo lavoro nella versione principale del progetto.

Merge completato

Conflitti durante il merge

Si verifica un conflitto quando Git non riesce a integrare automaticamente le modifiche. Succede spesso quando le stesse righe sono state modificate in modo diverso; può capitare anche se un branch elimina un file e un altro lo modifica. La soluzione dipende dal risultato desiderato.

È qui che si rivelano utili gli strumenti integrati nel Suo IDE (CLion o IntelliJ IDEA). Risolvere i conflitti dal terminale non è il massimo; lo strumento di merge a tre vie (3-way merge) dell'IDE rende invece tutto più chiaro e semplice.

Due branch con un antenato comune C1C1C2C3
Due branch con un antenato comune C1

Entrambi i branch hanno ricevuto commit a partire dall'antenato comune C1. La divergenza della cronologia, da sola, non basta a provocare un conflitto: questo si presenta quando Git non riesce a combinare automaticamente le modifiche. Nell'esercizio seguente, testi diversi sostituiscono la stessa riga originale.

Simuliamo un conflitto:

  1. si assicuri di trovarsi nel branch main e che nella finestra Commit non ci siano modifiche non committate né nuovi file;
  2. crei un nuovo branch feature/new-title, ma per ora non ci passi. Verifichi che la casella Checkout branch non sia selezionata;
  3. ora, mentre si trova nel branch main, modifichi la prima riga di README.md in "My Awesome Project" e crei un commit;
  4. passi al branch feature/new-title. Vedrà che la prima riga di README.md è ancora quella vecchia: è lo stato del file al momento della creazione del branch. Modifichi la stessa riga in "My Super Project" e crei un commit;
  5. torni al branch main ed esegua il merge con feature/new-title.

A questo punto Git rileverà che le due cronologie hanno modifiche diverse nello stesso punto. Le mostrerà la finestra per risolvere il conflitto (Merge Conflicts).

Finestra di rilevamento dei conflitti

Faccia clic sul pulsante Merge per aprire lo strumento di risoluzione dei conflitti. Qui trova:

  • a sinistra (Your changes) - la versione del file dal branch corrente, quello in cui integra le modifiche (main);
  • a destra (Changes from branch) - la versione del file dal branch che sta integrando;
  • al centro (Result) - la versione finale del file, da comporre manualmente.
Finestra a tre vie per risolvere i conflitti

Può fare clic sulle frecce >> o << (oppure sulle crocette per annullare) per accettare per intero una delle due versioni. In alternativa, può scrivere il testo corretto direttamente nel pannello centrale.

Controlli il risultato nel pannello centrale e faccia clic su Apply o sul pulsante equivalente per concludere. Poi verifichi lo stato di Git: se il merge non è ancora stato registrato, crei un commit dall'IDE. Risolvere le righe in conflitto e completare il merge sono due passaggi distinti. Verifichi il comportamento del codice risultante.

Collegamento con Claude Code

Se si verifica un conflitto mentre lavora con Claude Code, non è un errore: Claude può fermarsi e chiederLe aiuto, oppure suggerire come separare le modifiche. Può risolverlo con lo stesso strumento di merge a tre vie dell'IDE usato per gli altri conflitti.

Perché a volte non si verifica un conflitto

Se nell'esercizio non compare alcun conflitto, controlli da quale commit è stato creato il secondo branch e verifichi che entrambe le parti abbiano davvero sostituito la stessa riga con testi diversi. Git riesce a integrare automaticamente anche modifiche compatibili in branch divergenti. Un'altra possibilità è una cronologia lineare, in cui può avvenire un fast-forward:

Esempio:

  1. ha un commit qualsiasi in main (per esempio, C1);
  2. crea un nuovo commit nel branch main con il testo "My Awesome Project". Il branch main ora punta al commit C2;
  3. crea un branch feature/new-title dalla posizione corrente di main: anche il nuovo branch parte dal commit C2;
  4. crea un commit in feature/new-title con il testo "My Super Project". Il branch avanza e punta al commit C3;
  5. torna in main (che è ancora sul commit C2) e integra feature/new-title.

Git rileva che il branch main è un antenato diretto di feature/new-title: nella cronologia di main non sono comparsi nuovi commit mentre lavorava nell'altro branch. Perciò sposta semplicemente in avanti il puntatore di main fino al commit C3, senza conflitti.

main avanza da C2 a C3 senza un nuovo commitC1C2C3
main avanza da C2 a C3 senza un nuovo commit

La cronologia di main prosegue in quella di feature/new-title senza divergenze. Git può quindi far avanzare main: non c'è conflitto.

Esaminare la cronologia delle modifiche

Per capire meglio che cosa succede nel progetto, è utile consultarne la cronologia.

Apra la finestra dello strumento Git (di solito è un'icona nella barra laterale sinistra o nella parte inferiore dell'IDE) e selezioni la scheda Log o Show Git Log nella barra dello strumento Git. Vedrà una rappresentazione grafica di tutti i branch e i commit. Potrà così seguire con chiarezza da quale branch ne è nato un altro e dove sono stati uniti.

Finestra del log di Git

Faccia clic su un commit per vedere quali modifiche contiene, chi l'ha creato e quando. È una vera macchina del tempo per il Suo codice.

Collegamento con Claude Code

Le modifiche di Claude Code entreranno in questa cronologia quando saranno registrate con normali commit. Nel Git Log le vedrà insieme alle Sue: può aprire qualsiasi commit e verificare che cosa è cambiato.

Come funziona con Claude Code

Ora che conosce i branch, sarà più facile capire che cosa fa Claude Code quando lavora con il Suo repository. Ecco quali operazioni può svolgere per Lei e che cosa conviene controllare:

  • crea un branch separato, se previsto dall'incarico e dalle regole del progetto;
  • propone un commit nei momenti chiave: Lei legge il diff e decide se accettarlo o modificarlo;
  • aiuta a trovare il commit salvato che Le serve e a scegliere come tornare indietro, tenendo conto delle modifiche non committate;
  • in caso di conflitto durante il merge, può chiederLe aiuto: si risolve con lo stesso strumento dell'IDE;
  • sa preparare e commentare una pull request (PR, una proposta per integrare un branch in quello principale, per esempio tramite GitHub CLI).
Collegamento con Claude Code

Prima di accettare, controlli il diff, soprattutto se Claude propone di eliminare file o eseguire un merge. Così saprà sempre che cosa entrerà nella cronologia del progetto.

Articolo precedente: Il lavoro quotidiano con Git · Articolo successivo: Pull request: dalla creazione al merge