Cherry-pick : récupérer un commit précis

git cherry-pick copie un commit précis sur votre branche actuelle. Au lieu de fusionner toute une branche, vous sélectionnez uniquement les commits dont vous avez besoin. C'est l'outil de prédilection pour les backports de correctifs et les hotfixes ciblés.

Prérequis : Les branches en bref et Merge et conflits.

Ce que vous allez apprendre

Comprendre le mécanisme du cherry-pick et pourquoi les hashes changent
Appliquer un ou plusieurs commits d'une branche vers une autre
Résoudre les conflits qui surviennent lors d'un cherry-pick
Utiliser les options clés : -n, -x, --continue, --abort

Le principe

Imaginons que feature contient un correctif (commit C6) dont vous avez besoin sur main, mais la feature n'est pas encore terminée :

Avant cherry-pick :
           C4 ← C5  (main ← HEAD)
          /
C1 ← C2 ← C3
          \
           C6 ← C7  (feature)

Après git cherry-pick C6 :
           C4 ← C5 ← C6'  (main ← HEAD)
          /
C1 ← C2 ← C3
          \
           C6 ← C7  (feature)

C6' est un nouveau commit avec un hash différent mais le même contenu que C6. Le commit original reste intact sur feature.

Cherry-pick en pratique

Identifiez le hash du commit à récupérer :

git log feature --oneline

b3d7f2a (feature) Ajouter la validation email
a1c4e5f Corriger le timeout API    ← celui-ci

Basculez sur la branche cible :
Fenêtre de terminal
```
git switch main
```
Cherry-pickez le commit :
Fenêtre de terminal
```
git cherry-pick a1c4e5f
```
Git applique les modifications et crée un nouveau commit sur main.
Vérifiez le résultat :
Fenêtre de terminal
```
git log --oneline -3
```

Cherry-pick de plusieurs commits

Commits consécutifs (plage)

# Du commit A (exclu) au commit D (inclus)
git cherry-pick A..D

# Ou du commit A (inclus) au commit D (inclus)
git cherry-pick A^..D

Commits non consécutifs

git cherry-pick a1c4e5f b3d7f2a e8f9a0b

Git les applique dans l'ordre donné, un par un.

Options utiles

Option	Effet
`--no-commit` (`-n`)	Applique les modifications sans commiter (staging)
`--edit` (`-e`)	Ouvre l'éditeur pour modifier le message
`-x`	Ajoute `(cherry picked from commit ...)` au message
`--signoff` (`-s`)	Ajoute votre `Signed-off-by` au message

`--no-commit` : combiner plusieurs cherry-picks

--no-commit applique les modifications dans le staging sans créer de commit. Utile pour combiner plusieurs cherry-picks en un seul commit :

git cherry-pick --no-commit a1c4e5f
git cherry-pick --no-commit b3d7f2a
git commit -m "Backport: timeout API + validation email"

`-x` : traçabilité

L'option -x ajoute automatiquement la référence du commit source dans le message :

Corriger le timeout API

(cherry picked from commit a1c4e5f7d8b9c0e1f2a3b4c5d6e7f8a9b0c1d2e3)

Résoudre un conflit en cherry-pick

Si le cherry-pick entre en conflit, Git s'arrête (comme pour un merge) :

Éditez les fichiers en conflit, mêmes marqueurs <<<<<<<, =======, >>>>>>> qu'un merge
Marquez comme résolu :
Fenêtre de terminal
```
git add fichier-en-conflit.txt
```
Continuez le cherry-pick :
Fenêtre de terminal
```
git cherry-pick --continue
```

Pour abandonner le cherry-pick :

git cherry-pick --abort

Cas d'usage : le backport

Le scénario le plus fréquent est le backport : appliquer un correctif de main vers une branche de release antérieure.

# Correctif mergé sur main
git switch release/2.x
git cherry-pick -x abc1234
git push

Le correctif est maintenant sur la release 2.x sans intégrer toutes les nouveautés de main.

Cherry-pick vs merge vs rebase

Critère	Cherry-pick	Merge	Rebase
Granularité	1 commit précis	Branche entière	Branche entière
Crée un nouveau commit	Oui (nouveau hash)	Oui (commit de merge)	Oui (hash réécrits)
Historique	Commit dupliqué	Préservé avec losange	Linéaire
Cas d'usage	Backport, hotfix	Intégration standard	Mise à jour de branche

Quand choisir ?

Situation	Commande recommandée
Intégrer une branche feature complète	`git merge`
Mettre à jour votre branche sur `main`	`git rebase`
Backporter un correctif vers une ancienne branche	`git cherry-pick`
Appliquer un hotfix de `main` sur `release/1.x`	`git cherry-pick`
Récupérer un seul commit depuis une branche parallèle	`git cherry-pick`

Dépannage : problèmes courants

Symptôme	Cause probable	Solution
`CONFLICT` pendant le cherry-pick	Même zone modifiée sur la branche cible	Résolvez comme un merge, puis `--continue`
`empty commit` (rien à appliquer)	Le changement existe déjà sur la branche	Vérifiez avec `git log`, utilisez `--allow-empty` si voulu
`bad revision`	Hash de commit incorrect	Vérifiez le hash avec `git log branche --oneline`
Historique pollué de doublons	Cherry-pick + merge ensuite	Utilisez `-x` pour tracer, préférez merge quand possible

À retenir

git cherry-pick <hash> copie un commit sur la branche courante
Le commit créé a un hash différent mais le même contenu
-x ajoute une référence au commit source (traçabilité)
--no-commit applique sans commiter (pour combiner)
Cas d'usage principal : backporter un correctif sans merger toute la branche
En cas de conflit : résoudre → git add → git cherry-pick --continue

FAQ : git cherry-pick

Comment cherry-pick un commit précis sur une autre branche ?

Placez-vous sur la branche cible, puis lancez git cherry-pick suivi du hash du commit. Git rejoue les modifications de ce commit et crée un nouveau commit sur la branche courante. On récupère le hash avec git log sur la branche source.

Le cherry-pick rejoue un commit sur la branche courante :

git switch ma-branche-cible        # se placer sur la branche qui reçoit
git cherry-pick 4f2a1c9             # rejouer le commit par son hash

Git applique les modifications du commit 4f2a1c9 et crée un nouveau commit (avec un nouveau hash) sur ma-branche-cible. Récupérez le hash à copier avec git log --oneline sur la branche source. C'est l'outil idéal pour un backport ou un hotfix ciblé, sans fusionner toute une branche.

Comment faire un cherry-pick sans créer de commit ?

Utilisez git cherry-pick --no-commit (ou -n) : Git applique les modifications du commit dans le working directory et l'index, mais ne crée pas de commit. Pratique pour combiner plusieurs cherry-picks en un seul commit ou ajuster le contenu avant de valider.

Ajoutez l'option --no-commit (ou -n) :

git cherry-pick -n 4f2a1c9

Git applique les modifications dans le working directory et les stage, mais ne crée pas de commit. Deux usages classiques :

combiner plusieurs cherry-picks en un seul commit final : enchaînez plusieurs cherry-pick -n, puis un seul git commit ;
ajuster le contenu avant de valider (retirer un fichier, modifier un détail).

Terminez toujours par un git commit pour matérialiser le résultat.

Comment cherry-pick plusieurs commits à la fois ?

Pour des commits consécutifs, utilisez une plage avec git cherry-pick A^..B qui rejoue de A à B inclus. Pour des commits non consécutifs, listez leurs hashs séparés par des espaces. Git les applique dans l'ordre indiqué.

Deux cas :

# commits CONSECUTIFS : une plage (A inclus grace au ^)
git cherry-pick 4f2a1c9^..9b7d3e2

# commits NON consecutifs : la liste des hashs
git cherry-pick 4f2a1c9 8c1b2a4 e5f6a7b

Attention au ^ dans la plage : A..B exclut A, alors que A^..B inclut A. Les commits sont rejoués dans l'ordre indiqué ; en cas de conflit, le cherry-pick s'arrête sur le commit fautif et attend un git cherry-pick --continue.

Comment annuler ou abandonner un cherry-pick ?

Pendant un cherry-pick en cours (conflit), git cherry-pick --abort revient à l'état initial. Une fois le cherry-pick terminé et committé, on l'annule comme un commit normal avec git revert ou git reset selon qu'il a été poussé ou non.

Cela dépend de l'état :

# cherry-pick EN COURS (bloque sur un conflit) : tout annuler
git cherry-pick --abort

# cherry-pick DEJA termine et committe, non pousse : le retirer
git reset --hard HEAD~1

# cherry-pick deja pousse : creer un commit inverse
git revert <hash-du-cherry-pick>

Règle : --abort tant que le cherry-pick n'est pas fini, puis reset (local) ou revert (déjà partagé) une fois le commit créé.

Comment résoudre un conflit pendant un cherry-pick ?

Git s'arrête sur le commit en conflit. Éditez les fichiers marqués, ajoutez-les avec git add, puis reprenez avec git cherry-pick --continue. Pour ignorer ce commit et passer au suivant, utilisez git cherry-pick --skip.

Un cherry-pick qui rencontre un conflit s'interrompt et vous laisse la main :

# 1. éditer les fichiers en conflit (marqueurs <<<<<<< =======  >>>>>>>)
git add fichier-resolu.js       # marquer comme résolu
git cherry-pick --continue      # reprendre là où ça s'est arrêté

Deux échappatoires : git cherry-pick --skip ignore le commit fautif et passe au suivant (utile dans une plage), git cherry-pick --abort annule toute l'opération. Vérifiez l'état à tout moment avec git status.

Quelle différence entre cherry-pick, merge et rebase ?

cherry-pick rejoue un ou quelques commits choisis sur une autre branche. merge intègre toute une branche en préservant l'historique. rebase rejoue toute une série de commits sur une nouvelle base pour linéariser l'historique. On utilise cherry-pick pour un backport ou un hotfix ponctuel.

Trois outils, trois portées :

Commande	Ce qu'elle déplace	Quand l'utiliser
`cherry-pick`	un ou quelques commits choisis	backport, hotfix ponctuel
`merge`	toute une branche (historique préservé)	intégrer une feature terminée
`rebase`	une série de commits rejouée sur une nouvelle base	linéariser l'historique

En clair : cherry-pick quand vous voulez ce commit précis ailleurs, merge/rebase quand vous intégrez tout un travail. Le cherry-pick crée un nouveau commit (hash différent), ce qui peut créer des doublons si le commit est ensuite fusionné normalement.

Prochaines étapes

HEAD détaché Naviguez dans l'historique sans être sur une branche.

Rebase fondamental L'alternative pour intégrer une branche entière.

Gestion des branches Organisez et nettoyez vos branches.