Git Cherry-Pick: come selezionare e applicare commit specifici

Sintassi di Git Cherry-Pick

Capire la sintassi di git cherry-pick è fondamentale per usare al meglio questo comando. Non si tratta solo di selezionare commit, ma di applicarli con precisione per ottenere il risultato desiderato.

La sintassi di base per effettuare lo cherry-pick di un singolo commit è:

git cherry-pick <commit-hash>

• git cherry-pick: il comando che avvia l’operazione.
• <commit-hash>: l’identificatore univoco (hash SHA-1) del commit che vuoi selezionare. Puoi trovare questo hash eseguendo git log per elencare la cronologia dei commit.

Quando esegui il comando sopra, Git applica le modifiche dal commit specificato al branch corrente, creando un nuovo commit con le stesse modifiche ma con un hash diverso. 

È importante notare che il comando trasferisce solo il commit in sé, non il contesto o la storia dei parent dal branch originale.

Nuovo su Git e GitHub? Inizia con il version control in questo tutorial per principianti su GitHub e Git.

Come usare Git Cherry-Pick: esempi passo dopo passo

Ora che conosci la sintassi di base di git cherry-pick, è il momento di vedere il comando in azione.

Questa sezione offre esempi pratici che ti guidano attraverso scenari comuni, di base e più complessi, in cui lo cherry-pick è utile. Ogni esempio mostra come applicare le modifiche da uno o più commit a un altro branch. 

Esempio 1: cherry-pick di un singolo commit

Poniamo che tu abbia fatto una correzione in un branch di feature che vuoi applicare al branch main senza fare il merge dell’intero branch della feature.

• Per prima cosa, trova l’hash del commit che vuoi selezionare eseguendo:

git log

• Individua l’hash del commit. 
• Passa al branch main:

git checkout main

• Esegui il comando di cherry-pick (supponiamo che l’hash sia abc1234):

git cherry-pick abc1234

Quando esegui questo comando, Git applica le modifiche del commit identificato da abc1234 al branch corrente (in questo caso main). Git crea un nuovo commit su main che contiene le stesse modifiche dell’originale, ma con un nuovo hash.

Esempio 2: cherry-pick di più commit

In alcune situazioni potresti dover applicare diversi commit distinti da un branch a un altro. Supponiamo che tu abbia tre commit separati nel tuo branch di feature che vuoi portare nel branch main.

• Trova gli hash dei commit che vuoi selezionare usando git log:

git log

• Passa al branch main:

git checkout main

• Esegui il comando di cherry-pick elencando i commit:

git cherry-pick abc1234 def5678 ghi7890

Esempio 3: cherry-pick di un intervallo di commit

Mettiamo che tu abbia fatto una serie di commit sul branch della feature e voglia applicarli tutti in una volta al branch main senza specificare ogni commit singolarmente. Come fare?

• Usa git log per identificare i commit iniziale e finale che vuoi selezionare (ad es., da abc1234 a ghi7890).
• Passa al branch main:

git checkout main

• Esegui il comando di cherry-pick con un intervallo di commit:

git cherry-pick abc1234...ghi7890

Esempio 4: cherry-pick di un commit da un branch remoto

A volte una fix critica esiste in un branch remoto e vuoi applicarla al tuo branch locale senza unire l’intero branch. Ecco come fare:

• Recupera le ultime modifiche dal repository remoto

git fetch origin

• Elenca i commit nel branch remoto per trovare l’hash che ti serve:

git log origin/feature_branch --oneline

• Supponi che l’hash del commit sia abc1234.
• Passa al tuo branch main locale:

git checkout main

• Esegui lo cherry-pick del commit dal branch remoto:

git cherry-pick abc1234

Questo ti consente di applicare un commit da un branch remoto senza unire l’intero branch.

Devi effettuare il checkout di un branch remoto? Segui questa guida passo passo su Git checkout per i branch remoti.

Esempio 5: cherry-pick di un commit e sua modifica

Se fai lo cherry-pick di un commit ma devi apportare piccole modifiche prima di confermarlo, puoi usare la modalità interattiva di Git. Ecco come:

• Passa al branch di destinazione:

git checkout main

• Esegui lo cherry-pick del commit ma fermati prima del commit:

git cherry-pick -n abc1234

Il flag -n (o --no-commit) applica le modifiche ma non crea un commit.

• Modifica i file secondo necessità.
• Fai lo stage e conferma manualmente le modifiche:

git add .
git commit -m "Modified cherry-picked commit from feature_branch"

Questo è utile quando devi ritoccare un commit selezionato prima di finalizzarlo.

Gestione dei conflitti durante Git Cherry-Pick

I conflitti sono inevitabili quando si selezionano commit tra branch, soprattutto quando il codice è molto divergente. 

Anche se cherry-pick è progettato per applicare le modifiche in modo pulito, non sempre riesce a riconciliare automaticamente le differenze. In questi casi, i conflitti devono essere risolti manualmente. Capire come si generano e come gestirli è cruciale per completare un’operazione di cherry-pick.

Come si verificano i conflitti

I conflitti si verificano tipicamente quando le modifiche del commit selezionato si sovrappongono o contraddicono modifiche già presenti nel branch di destinazione. Per esempio:

• Stessa riga modificata in entrambi i branch: se la stessa riga di codice è modificata sia nel branch sorgente che in quello di destinazione, Git non saprà quale versione applicare.
• File eliminato in un branch ma modificato nell’altro: se un file è eliminato in un branch ma modificato nel commit selezionato, Git non saprà se mantenerlo o applicare le modifiche.
• Modifiche non correlate ma stesso file: anche quando le modifiche sembrano non correlate, se avvengono nello stesso file, Git potrebbe segnalarle come potenziale conflitto.

Quando si verifica un conflitto, Git interrompe l’operazione di cherry-pick, lasciando la working directory in uno stato di conflitto che deve essere risolto prima di procedere.

Risoluzione dei conflitti

Quando nasce un conflitto, Git indica i file interessati e dovrai risolvere manualmente le discrepanze. Ecco come procedere:

1. Verifica i file in conflitto: esegui il seguente comando per vedere quali file sono in conflitto:

git status

Il comando mostrerà l’elenco dei file con conflitti. 

2. Risolvi i conflitti: puoi modificare manualmente i file in conflitto per risolvere i problemi. Rimuovi i marcatori di conflitto (<<<<<<<, =======, >>>>>>>) e stabilisci quali modifiche mantenere o come combinarle.

3. Usa Git Mergetool (opzionale): se risolvere i conflitti a mano è scomodo, puoi usare uno strumento di merge per aiutarti a visualizzare e risolvere i conflitti:

git mergetool

In base alla tua configurazione, si aprirà uno strumento di merge visuale che facilita la revisione e la risoluzione dei conflitti.

4. Segna i conflitti come risolti: dopo aver risolto i conflitti, marca i file come risolti usando:

git add <conflicted-file>

5. Completa lo cherry-pick: una volta risolti tutti i conflitti e preparati i file, finalizza lo cherry-pick eseguendo:

git cherry-pick --continue

Molti IDE e strumenti moderni, come Visual Studio Code e GitHub, offrono funzionalità integrate per la risoluzione dei conflitti di merge. L’interfaccia web di GitHub ti permette di risolvere i conflitti direttamente nelle pull request, facilitando la collaborazione su repository condivisi senza passare all’ambiente locale.

Saltare un commit dopo un conflitto

A volte risolvere un conflitto può essere troppo complesso, oppure potresti renderti conto che il commit non è poi così necessario. In questi casi, puoi saltare del tutto il commit.

1. Interrompi l’attuale processo di cherry-pick: se il conflitto è troppo complicato e non vuoi applicare il commit, puoi saltarlo eseguendo:

git cherry-pick --skip

Questo abbandonerà il commit in conflitto e passerà al successivo (se stai selezionando più commit).

2. Annulla l’intero cherry-pick: se vuoi annullare del tutto l’operazione di cherry-pick, puoi eseguire:

git cherry-pick --abort

Questo comando ripristinerà la tua working directory allo stato precedente all’inizio dello cherry-pick. 

Vuoi ripulire la cronologia dei commit? Scopri come combinare più commit in uno solo con questo tutorial su Git squash.

Best practice per usare Git Cherry-Pick

Un uso improprio di cherry-pick può portare a storie complicate e confusione nel version control del tuo progetto. Per evitare questi problemi, seguire le best practice assicura di usare cherry-pick in modo efficace senza introdurre complessità inutili nel codebase.

Mantieni piccoli e specifici gli interventi

Lo cherry-pick è più efficace quando usato per commit piccoli e specifici che affrontano task ben definiti, come correzioni di bug o miglioramenti minori di funzionalità. 

Evita di selezionare commit grandi e complessi che raggruppano più modifiche, perché possono introdurre conflitti e rendere più difficile la gestione del codice. Più il commit è mirato, più è facile applicarlo senza effetti collaterali indesiderati.

Documenta gli cherry-pick

Per mantenere una cronologia chiara, fornisci sempre il contesto adeguato quando fai cherry-pick. Puoi farlo tramite messaggi di commit dettagliati o annotazioni nella documentazione. 

In sostanza, devi spiegare perché è stato necessario uno cherry-pick. Questo è particolarmente importante quando selezioni commit tra branch di lunga durata o in ambienti collaborativi, perché aiuta i contributor futuri a capire perché certe modifiche sono state applicate selettivamente.

Rivedi la cronologia dei commit

Prima di effettuare lo cherry-pick, rivedi la cronologia dei commit sia del branch sorgente che di quello di destinazione. Questo passaggio aiuta a capire se il commit che stai per selezionare dipende da altre modifiche. Dipendenze mancanti possono causare funzionalità incomplete o bug, quindi assicurati che lo cherry-pick non introduca aggiornamenti a metà.

Evita l’uso eccessivo dello cherry-pick

Sebbene lo cherry-pick sia comodo per applicare modifiche specifiche, abusarne può portare a una cronologia frammentata con commit duplicati tra i branch. Questo può rendere difficile risalire all’origine di certe modifiche o capire il contesto di sviluppo più ampio. 

Valuta sempre se un merge o un rebase sia una strategia più appropriata prima di usare lo cherry-pick. Usalo con parsimonia e con uno scopo preciso per evitare di appesantire la cronologia dei commit.

Hai difficoltà con file inutili in Git? Scopri come usare .gitignore in modo efficace con questo tutorial su Git ignore.

Risoluzione dei problemi comuni con Git Cherry-Pick

Risolvare i problemi che sorgono usando cherry-pick richiede una chiara comprensione dei meccanismi di Git. In questa sezione, affronterò alcuni problemi comuni che potresti incontrare durante lo cherry-pick e come risolverli.

Selezionare un commit che non esiste

A volte potresti provare a selezionare un commit che non è accessibile dal branch corrente o che è già stato unito. Questo di solito genera un messaggio di errore che indica che il commit non può essere trovato o applicato.

1. Commit non trovato: succede quando l’hash del commit che stai cercando di selezionare non esiste nel repository o nel contesto del branch corrente. Assicurati di fare riferimento al commit corretto controllando la cronologia con git log sul branch in cui il commit esiste. Soluzione:

• Ricontrolla l’hash del commit per assicurarti che sia corretto.
• Verifica che il commit esista su un branch a cui hai accesso.
• Se il commit è in un branch remoto, assicurati di averlo scaricato con git fetch.

2. Commit già applicato: se il commit è già stato fatto merge o selezionato nel branch di destinazione, Git impedirà di duplicarlo. Questa salvaguardia mantiene la cronologia pulita ed evita cambiamenti ridondanti. Soluzione:

• Usa git log per verificare se il commit è già nel branch di destinazione.
• Se necessario, salta l’operazione di cherry-pick poiché le modifiche sono già state applicate.

Cherry-pick dopo un rebase o un merge

Effettuare lo cherry-pick dopo un rebase o un merge può introdurre complessità a causa della cronologia dei branch modificata. Il rebase riscrive la cronologia dei commit, mentre il merge combina branch: entrambi possono influire sull’applicabilità di uno cherry-pick.

1. Conflitti dovuti a commit riscritti: dopo un rebase, la cronologia viene riscritta, il che può causare problemi se provi a selezionare commit che sono stati alterati nel processo. Potresti incontrare conflitti perché il cherry-pick tenta di applicare modifiche che non si allineano con la cronologia riscritta. Soluzione:

• Rivedi con attenzione la cronologia dopo un rebase usando git log per assicurarti che il commit che vuoi selezionare non sia già stato modificato.
• Risolvi i conflitti come in un normale processo di cherry-pick, usando git status ed edit manuali.

2. Commit duplicati dopo un merge: unire branch può portare a situazioni in cui un commit che vuoi selezionare è già incluso nella cronologia unita. Selezionarlo di nuovo può creare duplicati, che intasano la cronologia e complicano il tracciamento dei cambiamenti. Soluzione:

• Prima di procedere, ispeziona la cronologia su entrambi i branch per confermare se il commit è già stato unito.
• Evita di selezionare lo stesso commit se è già presente nel branch di destinazione.

Devi annullare modifiche in Git? Scopri quando usare git reset vs. git revert in questo tutorial su Git reset e revert.

Conclusione

git cherry-pick è un modo potente per applicare commit specifici da un branch a un altro senza unire l’intero branch. Che tu stia spostando una correzione, un aggiornamento di feature o applicando selettivamente modifiche, aiuta a mantenere la cronologia di Git pulita e focalizzata.

In questa guida ho spiegato come selezionare uno o più commit, risolvere i conflitti e seguire le best practice per evitare errori comuni. Usando cherry-pick con criterio, puoi migliorare il tuo workflow mantenendo il repository ordinato.

Se vuoi approfondire le tue competenze su Git, dai un’occhiata a Foundations of Git per partire con il piede giusto. Puoi anche esplorare Introduction to GitHub Concepts o seguire un percorso strutturato con lo skill track GitHub Foundations.

Ora che sai fare cherry-pick come un professionista, provalo nel tuo prossimo progetto!