Git Cherry-Pick : Comment sélectionner et appliquer des commits spécifiques

Syntaxe du Cherry-Pick Git

Comprendre la syntaxe de git cherry-pick est essentiel pour utiliser efficacement cette commande. Il ne s’agit pas seulement de sélectionner des commits, mais de les appliquer de manière précise pour obtenir le résultat souhaité.

La syntaxe de base pour choisir un seul commit est:

git cherry-pick <commit-hash>

• git cherry-pick: La commande qui lance l’opération.
• <commit-hash>: L’identifiant unique (hash SHA-1) du commit que vous souhaitez choisir. Ce hash peut être trouvé en exécutant git log pour lister l’historique des commits.

Lors de l’exécution de la commande ci-dessus, Git applique les changements du commit spécifié à la branche actuelle, créant un nouveau commit avec les mêmes changements mais un hash différent.

Il est important de noter que la commande transfère uniquement le commit lui-même, pas le contexte ou l’historique parent de la branche d’origine.

Nouveau sur Git et GitHub ? Commencez avec le contrôle de version dans ce tutoriel convivial pour débutants.Github et tutoriel Git.

Comment utiliser Git Cherry-Pick : Exemples étape par étape

Maintenant que vous comprenez la syntaxe de base de git cherry-pick, il est temps de voir la commande en action.

Cette section propose des exemples pratiques qui vous guident à travers des scénarios basiques courants et plus complexes où le cherry-picking est utile. Chaque exemple illustre comment appliquer les modifications d’un ou de plusieurs commits à une autre branche.

Exemple 1 : Cherry-pick d’un seul commit

Disons que vous avez apporté une correction sur une branche de fonctionnalité que vous souhaitez appliquer à la branche principale sans fusionner toute la branche de fonctionnalité.

• Tout d’abord, trouvez le hachage du commit que vous souhaitez cherry-pick en exécutant :

git log

• Localisez le hachage du commit.
• Changez à la branche principale :

git checkout main

• Exécutez la commande cherry-pick (supposez que le hachage est abc1234) :

git cherry-pick abc1234

Lorsque vous exécutez cette commande, Git appliquera les modifications du commit identifié par abc1234 à votre branche actuelle (qui est main dans ce cas). Git crée un nouveau commit sur la branche principale qui contient les mêmes modifications que le commit original mais avec un nouveau hachage de commit.

Exemple 2 : Sélectionner plusieurs commits

Dans certaines situations, vous pouvez avoir besoin d’appliquer plusieurs commits distincts d’une branche à une autre. Supposons que vous ayez trois commits distincts dans votre branche de fonctionnalité que vous devez intégrer dans la branche principale.

• Recherchez les hachages de commit pour chaque commit que vous souhaitez sélectionner en utilisant git log :

git log

• Passez à la branche principale :

git checkout main

• Exécutez la commande cherry-pick en listant les commits :

git cherry-pick abc1234 def5678 ghi7890

Exemple 3 : Choisir un intervalle de commits à appliquer

Imaginons que vous avez effectué une série de commits sur la branche de fonctionnalité et que vous souhaitez les appliquer à la branche principale en une seule fois sans spécifier chaque commit individuellement. Comment feriez-vous ?

• Utilisez git log pour identifier les commits de début et de fin que vous souhaitez choisir (par exemple, abc1234 à ghi7890).
• Basculez vers la branche principale :

git checkout main

• Exécutez la commande cherry-pick avec un intervalle de commits :

git cherry-pick abc1234...ghi7890

Exemple 4 : Choisir un commit depuis une branche distante

Parfois, une correction critique existe dans une branche distante, et vous voulez l’appliquer à votre branche locale sans fusionner toute la branche. Voici comment faire :

• Récupérez les derniers changements du dépôt distant

git fetch origin

• Listez les commits dans la branche distante pour trouver le hachage dont vous avez besoin :

git log origin/feature_branch --oneline

• Supposez que le hachage du commit dont vous avez besoin est abc1234.
• Passez à votre branche principale locale :

git checkout main

• Appliquez le commit de la branche distante en utilisant Cherry-Pick :

git cherry-pick abc1234

Cela vous permet d’appliquer un commit d’une branche distante sans fusionner toute la branche.

Besoin de vérifier une branche distante ? Suivez ce guide étape par étape sur Git checkout pour les branches distantes.

Exemple 5 : Choisir un commit et le modifier

Si vous choisissez un commit mais avez besoin de faire de légères modifications avant de valider, vous pouvez utiliser le mode interactif de Git. Voici comment faire :

• Passer à la branche cible :

git checkout main

• Choisir le commit mais arrêter avant de valider :

git cherry-pick -n abc1234

Le drapeau -n (ou --no-commit) applique les modifications mais ne crée pas de commit.

• Modifiez les fichiers selon vos besoins.
• Validez et committez les modifications manuellement :

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

Ceci est utile lorsque vous devez ajuster un commit cherry-pické avant de le finaliser.

Gestion des conflits lors du cherry-pick Git

Les conflits sont inévitables lors du cherry-pick de commits entre branches, surtout lorsque la base de code a divergé significativement.

Alors que cherry-pick est conçu pour appliquer les modifications proprement, il ne peut pas toujours concilier automatiquement les différences. Dans ces cas, les conflits doivent être résolus manuellement. Comprendre comment les conflits surviennent et comment les gérer est crucial pour mener à bien une opération de cherry-pick.

Comment les conflits se produisent

Les conflits surviennent généralement lorsque les modifications du commit cherry-pick chevauchent ou contredisent les modifications déjà présentes dans la branche cible. Par exemple :

• Même ligne modifiée dans les deux branches : Si la même ligne de code est modifiée à la fois dans les branches source et cible, Git ne saura pas quelle version appliquer.
• Fichier supprimé dans une branche mais modifié dans une autre : Si un fichier est supprimé dans une branche mais modifié dans le commit cherry-pické, Git ne saura pas s’il faut le conserver ou appliquer les changements.
• Changements non liés mais même fichier : Même lorsque les changements semblent non liés, s’ils se produisent dans le même fichier, Git peut le signaler comme un conflit potentiel.

Lorsqu’un conflit survient, Git arrêtera l’opération de cherry-pick, laissant votre répertoire de travail dans un état de conflit qui doit être résolu avant de continuer.

Résolution des conflits

Une fois qu’un conflit survient, Git fournira des indicateurs des fichiers en conflit, et vous devrez résoudre manuellement les divergences. Voici comment résoudre les conflits:

1. Vérifiez les fichiers en conflit: Exécutez la commande suivante pour voir quels fichiers sont en conflit:

git status

La commande affichera la liste des fichiers en conflit.

2. Résolvez les conflits: Vous pouvez éditer manuellement les fichiers en conflit pour résoudre les problèmes. Supprimez les marqueurs de conflit (<<<<<<<, =======, >>>>>>>) et déterminez quels changements conserver ou comment les combiner.

3. Utiliser Git Mergetool (optionnel) : Si résoudre les conflits manuellement est fastidieux, vous pouvez utiliser un outil de fusion pour vous aider à visualiser et résoudre les conflits :

git mergetool

En fonction de votre configuration, l’outil ci-dessus ouvrira un outil de fusion visuel, ce qui facilite la révision et la résolution des conflits.

4. Marquer les conflits comme résolus : Après avoir résolu les conflits, marquez les fichiers comme résolus en utilisant :

git add <conflicted-file>

5. Complétez la sélection des commits :Une fois que tous les conflits sont résolus et que les fichiers sont mis en attente, finalisez la sélection des commits en exécutant :

git cherry-pick --continue

De nombreux IDE et outils modernes, tels que Visual Studio Code et GitHub, offrent des fonctionnalités intégrées de résolution de conflits de fusion. L’interface web de GitHub vous permet de résoudre les conflits directement dans les demandes de fusion, facilitant la collaboration sur des dépôts partagés sans avoir à passer à un environnement local.

Passer un commit après un conflit

Parfois, la résolution d’un conflit peut être trop complexe, ou vous pouvez réaliser que le commit n’est finalement pas nécessaire. Dans de tels cas, vous pouvez passer complètement le commit.

1. Interrompre le processus de cherry-pick en cours : Si le conflit est trop compliqué et que vous ne souhaitez pas appliquer le commit, vous pouvez le sauter en exécutant :

git cherry-pick --skip

Cela abandonnera le commit en conflit et passera au suivant (si vous êtes en train de cherry-pick plusieurs commits).

2. Interrompre complètement le cherry-pick : Si vous souhaitez annuler complètement l’opération de cherry-pick, vous pouvez exécuter :

git cherry-pick --abort

Cette commande restaurera votre répertoire de travail à l’état dans lequel il se trouvait avant que vous ne commenciez le cherry-pick.

Voulez-vous nettoyer votre historique de commits ? Apprenez comment regrouper plusieurs commits en un seul avec ce tutoriel sur le squash Git.

Meilleures pratiques pour utiliser Git Cherry-Pick

L’utilisation incorrecte de cherry-pick peut entraîner des historiques compliqués et de la confusion dans le contrôle de version de votre projet. Pour éviter ces écueils, le respect des meilleures pratiques garantit que vous utilisez cherry-pick de manière efficace sans introduire de complexité inutile dans votre base de code.

Gardez-le petit et spécifique

Le cherry-picking est le plus efficace lorsqu’il est utilisé pour de petits commits spécifiques qui répondent à des tâches bien définies, telles que des corrections de bogues ou des améliorations mineures de fonctionnalités.

Évitez de choisir sélectivement de gros commits complexes regroupant plusieurs modifications, car cela peut entraîner des conflits et rendre la gestion de la base de code plus difficile. Plus le commit est ciblé, plus il est facile à appliquer sans effets secondaires non intentionnels.

Documentez vos sélections sélectives

Pour maintenir un historique clair, fournissez toujours un contexte approprié lors de la sélection sélective. Cela peut être fait via des messages de commit détaillés ou des annotations dans la documentation.

L’idée principale est que vous devez expliquer pourquoi une sélection sélective était nécessaire. C’est particulièrement important lors de la sélection sélective à travers des branches de longue durée ou des environnements collaboratifs, car cela aide les futurs contributeurs à comprendre pourquoi les modifications ont été appliquées de manière sélective.

Revoyez l’historique des commits

Avant de faire un cherry-pick, examinez l’historique des commits des branches source et cible. Cette étape permet d’identifier si le commit que vous vous apprêtez à cherry-pick dépend d’autres modifications. Des dépendances manquantes peuvent entraîner un fonctionnement incomplet ou des bugs, donc assurez-vous que le cherry-pick n’introduit pas de fonctionnalités ou de mises à jour bâclées.

Évitez l’abus du cherry-picking

Alors que le cherry-picking est pratique pour appliquer des changements spécifiques, en abuser peut entraîner une histoire fragmentée avec des commits dupliqués à travers les branches. Cela peut rendre difficile de retracer l’origine de certains changements ou de comprendre le contexte plus large du développement.

Évaluez toujours si la fusion ou le rebasage est une stratégie plus appropriée avant de faire du cherry-picking. Utilisez cherry-pick avec parcimonie et de manière réfléchie pour éviter d’encombrer l’historique des commits.

Vous avez des problèmes avec des fichiers inutiles dans Git? Apprenez à utiliser .gitignore de manière efficace avec ce tutoriel sur l’ignorance de Git.

Résolution des problèmes courants avec Git Cherry-Pick

La résolution des problèmes qui surviennent lors de l’utilisation de cherry-pick nécessite une compréhension claire des mécanismes sous-jacents de Git. Dans cette section, je couvrirai certains problèmes courants que vous pourriez rencontrer lors de la réalisation d’un cherry-pick et comment les résoudre.

Cherry-pick d’un commit qui n’existe pas

Parfois, vous pouvez essayer de cherry-pick un commit qui n’est pas accessible à partir de la branche actuelle ou qui a déjà été fusionné. Cela se traduit généralement par un message d’erreur indiquant que le commit n’a pas pu être trouvé ou appliqué.

1. Commit introuvable: Cela se produit lorsque le hachage du commit que vous essayez de cherry-pick n’existe pas dans votre dépôt ou contexte de branche actuel. Assurez-vous que vous faites référence au bon commit en vérifiant l’historique des commits avec git log sur la branche où le commit existe. Solution:

• Vérifiez à nouveau le hachage du commit pour vous assurer qu’il est correct.
• Vérifiez que le commit existe sur une branche à laquelle vous avez accès.
• Si le commit est dans une branche distante, assurez-vous que la branche a été récupérée avec git fetch.

2. Valider déjà appliqué: Si le commit a déjà été fusionné ou récupéré dans la branche cible, Git vous empêchera de le dupliquer. Cette mesure de sécurité permet de maintenir l’historique propre et d’éviter les changements redondants. Solution:

• Utilisez git log pour vérifier si le commit est déjà présent dans la branche cible.
• Si nécessaire, évitez l’opération cherry-pick car les changements ont déjà été appliqués.

Récupération après un rebase ou une fusion

Récupérer après un rebase ou une fusion peut introduire des complexités en raison de l’historique modifié de vos branches. Le rebase réécrit l’historique des commits tandis que la fusion combine les branches, ce qui peut affecter la possibilité d’un cherry-pick.

1. Conflits dus aux commits rebase: Après un rebase, l’historique des commits est réécrit, ce qui peut causer des problèmes si vous essayez de cherrypick des commits qui ont été modifiés pendant le processus de rebase. Vous pouvez rencontrer des conflits lorsque le cherry-pick tente d’appliquer des changements qui ne correspondent pas à l’historique réécrit. Solution:

• Examinez attentivement l’historique des commits après un rebase en utilisant git log pour vous assurer que le commit que vous voulez cherrypicker n’a pas déjà été modifié.
• Résolvez les conflits comme vous le feriez dans un processus de cherry-pick standard, en utilisant git status et des modifications manuelles.

2. Commits en double après une fusion : La fusion de branches peut conduire à une situation où un commit que vous souhaitez cherry-pick a déjà été inclus dans l’historique fusionné. Le cherry-picking de ce commit à nouveau peut entraîner des commits en double, ce qui peut encombrer votre historique et rendre difficile le suivi des changements. Solution :

• Avant de cherry-pick, inspectez l’historique des commits sur les deux branches pour confirmer si le commit a déjà été fusionné.
• Évitez de cherry-pick le même commit s’il est déjà dans la branche cible.

Besoin d’annuler des changements dans Git ? Apprenez quand utiliser git reset vs. git revert dans ce tutoriel sur reset et revert Git.

Conclusion

git cherry-pick est un moyen puissant d’appliquer des commits spécifiques d’une branche à une autre sans fusionner l’ensemble de la branche. Que vous déplaciez une correction de bug, une mise à jour de fonctionnalité ou que vous appliquiez sélectivement des changements, cela aide à garder votre historique Git propre et concentré.

Dans ce guide, j’ai couvert comment cherry-pick des commits uniques et multiples, résoudre les conflits et suivre les bonnes pratiques pour éviter les écueils courants. En utilisant cherry-pick judicieusement, vous pouvez améliorer votre flux de travail tout en gardant votre dépôt organisé.

Si vous souhaitez approfondir vos compétences Git, consultez Foundations of Git pour un point de départ solide. Vous pouvez également explorer Introduction to GitHub Concepts ou adopter une approche structurée avec la GitHub Foundations skill track.

Maintenant que vous savez comment faire du cherry-pick comme un pro, n’hésitez pas à l’essayer dans votre prochain projet!