Parcourir les aide-mémoire · Git

Technologie: GitCatégorie: Gestion de versionsNiveau: IntermédiaireMis à jour

Résoudre les conflits de fusion

Résolvez les conflits de fusion Git en toute sécurité en identifiant l’opération en cours, en comprenant ours et theirs, en vérifiant le résultat combiné attendu, puis en terminant ou en annulant le merge sans perdre de travail.

Sur cette page
  1. Problème
  2. Réponse rapide
  3. Code / commandes
  4. 1. Identifier l’opération Git en cours
  5. 2. Lister uniquement les fichiers non résolus
  6. 3. Examiner les sections non résolues
  7. 4. Comprendre les marqueurs de conflit
  8. 5. Ne pas conserver les marqueurs de conflit
  9. 6. Comprendre ours et theirs pendant un merge normal
  10. 7. Être prudent avec ours et theirs pendant un rebase
  11. 8. Accepter le côté courant pour un fichier pendant un merge
  12. 9. Accepter le côté entrant pour un fichier pendant un merge
  13. 10. Examiner directement les versions des étapes de l’index
  14. 11. Afficher la version de l’ancêtre commun
  15. 12. Afficher la version ours
  16. 13. Afficher la version theirs
  17. 14. Résoudre manuellement lorsque les deux côtés contiennent des modifications valides
  18. 15. Ajouter un fichier résolu à l’index
  19. 16. Confirmer les fichiers qui restent non résolus
  20. 17. Vérifier la résolution indexée
  21. 18. Terminer un merge normal
  22. 19. Annuler un merge normal
  23. 20. Poursuivre un rebase après la résolution
  24. 21. Annuler un rebase
  25. 22. Ne pas utiliser git rebase --skip simplement pour éviter un conflit
  26. 23. Poursuivre un cherry-pick après des conflits
  27. 24. Annuler un cherry-pick
  28. 25. Poursuivre un revert après des conflits
  29. 26. Annuler un revert
  30. 27. Gérer les conflits d’un stash apply
  31. 28. Conserver le stash jusqu’à ce que la restauration soit vérifiée
  32. 29. Utiliser git stash branch pour un ancien stash riche en conflits
  33. 30. Résoudre délibérément les conflits suppression/modification
  34. 31. Résoudre les conflits ajout/ajout
  35. 32. Résoudre prudemment les conflits de renommage
  36. 33. Comparer les modifications des branches avant de retenter un merge difficile
  37. 34. Créer une branche de sécurité avant un travail complexe sur les conflits
  38. 35. Utiliser mergetool uniquement s’il apporte de la clarté
  39. 36. Configurer explicitement un outil de fusion
  40. 37. Utiliser l’éditeur de fusion de VS Code lorsque c’est pertinent
  41. 38. Rechercher les marqueurs de conflit avant de faire le commit
  42. 39. Lancer le formatage seulement après la résolution sémantique
  43. 40. Lancer les tests après la résolution
  44. 41. Examiner le résultat indexé exact avant de terminer
  45. 42. Ne pas inclure de nettoyage sans rapport dans la résolution des conflits
  46. 43. Résoudre les fichiers générés à partir de leur source lorsque c’est possible
  47. 44. Gérer les conflits de fichiers de verrouillage avec le gestionnaire de paquets lorsque c’est possible
  48. 45. Ne pas résoudre les conflits binaires par fusion de texte
  49. 46. Surveiller les conflits sémantiques que Git ne signale pas
  50. 47. Surveiller la logique dupliquée après des merges sans conflit
  51. 48. Utiliser git log --merge pendant un merge en conflit
  52. 49. Examiner l’historique d’un fichier en conflit
  53. 50. Utiliser blame pour le contexte historique, pas pour désigner un coupable
  54. 51. Comprendre les conflits répétés pendant un rebase
  55. 52. Activer rerere uniquement si vous le comprenez
  56. 53. Afficher l’état de rerere
  57. 54. Privilégier des branches plus petites et plus éphémères
  58. 55. Intégrer séparément les refactorisations structurelles lorsque c’est possible
  59. 56. Éviter de profiter de la résolution des conflits pour « tout nettoyer »
  60. 57. Vérifier le sens d’intégration des branches après la résolution
  61. 58. Vérifier le diff de la fonctionnalité après un rebase
  62. 59. Utiliser reflog si la résolution des conflits ou le travail sur l’historique tourne mal
  63. 60. Mettre en place une démarche reproductible de résolution des conflits
  64. Interpréter le résultat
  65. Points à vérifier
  66. Le conflit apparaît dans un fichier fortement modifié par les deux branches
  67. Le même conflit revient plusieurs fois pendant un rebase
  68. ours / theirs semble inversé
  69. Le merge se termine mais les tests échouent
  70. Un nombre énorme de conflits apparaît de façon inattendue
  71. Le conflit ne concerne que de la sortie générée
  72. Notes de production
  73. Un conflit est une décision d’intégration
  74. La résolution des conflits doit pouvoir être relue
  75. L’historique d’une branche partagée ne doit pas être réécrit simplement pour éviter de résoudre des conflits
  76. Les tests font partie de la résolution des conflits
  77. Une résolution assistée par un outil exige toujours du discernement
  78. La fréquence des conflits est un signal sur le mode de travail
  79. Erreurs fréquentes
  80. 1. Choisir ours/theirs sans vérifier l’opération
  81. 2. Cliquer automatiquement sur « Accept Both »
  82. 3. Ajouter un fichier à l’index avant de vérifier la résolution
  83. 4. Lancer reset --hard lorsqu’un conflit apparaît
  84. 5. Utiliser rebase --skip pour éviter des conflits difficiles
  85. 6. Laisser des marqueurs de conflit dans le code source
  86. 7. Résoudre manuellement des fichiers générés sans vérifier le processus de génération
  87. 8. Considérer un merge Git sans conflit comme une fusion correcte de l’application
  88. 9. Mélanger une refactorisation sans rapport avec la résolution
  89. 10. Poursuivre avant d’avoir traité tous les chemins non résolus
  90. Étape suivante
  91. Pour aller plus loin

Problème

Git s’est arrêté pendant un merge, un rebase, un cherry-pick, un stash apply ou un revert, parce que deux modifications n’ont pas pu être combinées automatiquement.

Le plus difficile n’est pas de supprimer les marqueurs de conflit.

Le vrai problème est de décider ce que doit être le code final, sans :

  • perdre des modifications valides de l’un ou l’autre côté
  • choisir ours ou theirs à l’aveugle
  • résoudre le conflit par rapport à la mauvaise branche
  • faire un commit contenant des marqueurs de conflit
  • masquer des conflits sémantiques que Git ne peut pas détecter
  • terminer la mauvaise opération Git
  • détruire du travail en essayant de récupérer la situation

L’objectif est d’identifier l’opération, de comprendre les deux côtés, de résoudre selon le comportement voulu, de valider le résultat, puis de poursuivre ou d’annuler en toute sécurité.

Réponse rapide

Commencez par :

git status

Listez les fichiers non résolus :

git diff --name-only --diff-filter=U

Examinez les conflits :

git diff

Un conflit se présente généralement ainsi :

<<<<<<< HEAD
current-side content
=======
incoming-side content
>>>>>>> branch-or-commit

Résolvez le fichier manuellement, supprimez les marqueurs, puis ajoutez-le à l’index :

git add path/to/file

Terminez l’opération :

Merge
→ git commit

Rebase
→ git rebase --continue

Cherry-pick
→ git cherry-pick --continue

Revert
→ git revert --continue

Si l’opération est la mauvaise ou n’est pas sûre :

Merge
→ git merge --abort

Rebase
→ git rebase --abort

Cherry-pick
→ git cherry-pick --abort

Revert
→ git revert --abort

Ne lancez pas git reset --hard simplement parce qu’un conflit est apparu.

Code / commandes

1. Identifier l’opération Git en cours

Exécutez :

git status

Git vous indique si vous êtes dans :

  • un merge
  • un rebase
  • un cherry-pick
  • un revert
  • un état normal de l’arbre de travail

La bonne commande pour poursuivre ou annuler dépend de l’opération.


2. Lister uniquement les fichiers non résolus

git diff --name-only --diff-filter=U

Vous obtenez les fichiers que Git considère encore comme non fusionnés.

Utilisez-la lorsqu’un conflit s’étend sur de nombreux fichiers.


3. Examiner les sections non résolues

git diff

Pendant une opération de type merge non résolue, cette commande affiche les zones en conflit et les modifications qui les entourent.

Examinez le code, pas seulement les noms de fichiers.


4. Comprendre les marqueurs de conflit

Conflit typique :

<<<<<<< HEAD
return old_behavior();
=======
return new_behavior();
>>>>>>> feature/new-behavior

Les sections signifient :

<<<<<<< HEAD
contenu provenant d’un côté

=======
séparateur

>>>>>>> ...
contenu provenant de l’autre côté

Votre travail consiste à remplacer l’intégralité du bloc en conflit par le code final correct.


5. Ne pas conserver les marqueurs de conflit

Mauvais fichier final :

<<<<<<< HEAD
...
=======
...
>>>>>>> feature

Git peut accepter l’ajout à l’index si les marqueurs ont été modifiés de façon inhabituelle, mais l’application contiendra alors un contenu invalide ou non voulu.

Effectuez une recherche avant de faire le commit :

git grep -n '<<<<<<<\|=======\|>>>>>>>'

Examinez chaque correspondance, car certains dépôts peuvent contenir volontairement des chaînes similaires dans des tests ou de la documentation.


6. Comprendre ours et theirs pendant un merge normal

Si vous êtes sur :

main

et que vous lancez :

git merge feature/report-engine

alors, pendant ce merge :

ours
→ main / branche courante

theirs
→ feature/report-engine / branche entrante

C’est le cas intuitif.


7. Être prudent avec ours et theirs pendant un rebase

Pendant un rebase, les libellés peuvent sembler inversés par rapport au modèle mental du développeur, car Git rejoue les commits sur la nouvelle base.

Ne décidez pas en vous fiant uniquement aux mots.

Utilisez :

git status
git diff

et examinez le contenu réel.

Résolvez en fonction du code final voulu.


8. Accepter le côté courant pour un fichier pendant un merge

git restore --ours path/to/file

Ajoutez-le ensuite à l’index :

git add path/to/file

À utiliser uniquement lorsque le fichier entier doit provenir du côté courant.


9. Accepter le côté entrant pour un fichier pendant un merge

git restore --theirs path/to/file

Puis :

git add path/to/file

À utiliser uniquement lorsque le fichier entier doit provenir du côté entrant.

La plupart des conflits réels exigent plutôt une résolution manuelle combinée.


10. Examiner directement les versions des étapes de l’index

Pendant un conflit non fusionné, l’index de Git (la zone de préparation) peut contenir plusieurs étapes (stages).

Examinez-les avec :

git ls-files -u

Étapes habituelles :

1 = ancêtre commun
2 = ours
3 = theirs

C’est utile pour un débogage avancé lorsque les marqueurs de conflit ne sont pas clairs.


11. Afficher la version de l’ancêtre commun

git show :1:path/to/file

À utiliser lorsque vous devez comprendre à partir de quoi les deux côtés ont modifié le fichier.


12. Afficher la version ours

git show :2:path/to/file

13. Afficher la version theirs

git show :3:path/to/file

Ces références d’étape sont particulièrement utiles pour l’analyse manuelle de conflits complexes.


14. Résoudre manuellement lorsque les deux côtés contiennent des modifications valides

Exemple de conflit :

<<<<<<< HEAD
timeout = 30
retries = 2
=======
timeout = 60
backoff_seconds = 5
>>>>>>> feature/retry-policy

Résultat combiné correct possible :

timeout = 60
retries = 2
backoff_seconds = 5

La bonne réponse dépend de l’intention de l’application.

Un conflit est une décision de conception du code, pas un exercice de sélection de texte.


15. Ajouter un fichier résolu à l’index

git add path/to/file

L’ajout à l’index indique à Git :

Je considère ce conflit comme résolu.

Cela ne prouve pas que la résolution est correcte.


16. Confirmer les fichiers qui restent non résolus

git status

ou :

git diff --name-only --diff-filter=U

Ne poursuivez pas tant que la liste des fichiers non résolus n’est pas vide.


17. Vérifier la résolution indexée

Après l’ajout à l’index :

git diff --cached

C’est essentiel.

Cette commande montre ce qui sera enregistré lorsque le merge, le rebase, le cherry-pick ou le revert se poursuivra.


18. Terminer un merge normal

Une fois tous les conflits ajoutés à l’index :

git commit

Git prépare normalement un message de commit de merge.

Relisez-le avant de l’enregistrer.


19. Annuler un merge normal

git merge --abort

À utiliser lorsque :

  • vous avez fait un merge de la mauvaise branche
  • l’ampleur du conflit est étonnamment importante
  • l’approche d’intégration n’est pas sûre
  • vous devez revenir à l’état antérieur au merge

20. Poursuivre un rebase après la résolution

git add path/to/file
git rebase --continue

Recommencez pour chaque commit rejoué qui entre en conflit.


21. Annuler un rebase

git rebase --abort

Cette commande ramène la branche vers son état antérieur au rebase.

À utiliser lorsque la base choisie ou la stratégie de rebase était mauvaise.


22. Ne pas utiliser git rebase --skip simplement pour éviter un conflit

git rebase --skip

supprime le commit en cours de rejeu.

À utiliser uniquement lorsque ce commit est réellement inutile ou déjà représenté ailleurs.


23. Poursuivre un cherry-pick après des conflits

git add path/to/file
git cherry-pick --continue

24. Annuler un cherry-pick

git cherry-pick --abort

À utiliser si le commit sélectionné ne doit pas être appliqué.


25. Poursuivre un revert après des conflits

git add path/to/file
git revert --continue

26. Annuler un revert

git revert --abort

À utiliser lorsque l’inversion du commit n’est pas sûre ou que le mauvais commit a été sélectionné.


27. Gérer les conflits d’un stash apply

Si :

git stash apply stash@{0}

crée des conflits, utilisez :

git status
git diff

Résolvez les fichiers et ajoutez-les à l’index normalement.

La commande suivante :

git stash --continue

n’existe pas.


28. Conserver le stash jusqu’à ce que la restauration soit vérifiée

Lorsqu’un travail important est en jeu :

git stash apply stash@{0}

est plus sûr que :

git stash pop

car le stash reste disponible pendant que vous résolvez les conflits et vérifiez l’arbre de travail.


29. Utiliser git stash branch pour un ancien stash riche en conflits

git stash branch recovered-wip stash@{0}

Cette commande crée une branche à partir du commit sur lequel le stash a été créé à l’origine, y applique le stash, puis le supprime si l’application réussit.

Cela peut réduire les conflits lorsque la branche courante s’est fortement éloignée.


30. Résoudre délibérément les conflits suppression/modification

Exemple :

une branche a supprimé config.py
l’autre branche a modifié config.py

Demandez-vous :

Le fichier doit-il encore exister ?

Si oui, restaurez-le ou résolvez-le, puis ajoutez-le à l’index.

Si non, supprimez-le et ajoutez la suppression à l’index :

git rm config.py

Ne conservez ni ne supprimez le fichier automatiquement sans comprendre pourquoi l’un des côtés l’a supprimé.


31. Résoudre les conflits ajout/ajout

Si les deux branches ont créé le même chemin avec un contenu différent, Git ne peut pas savoir s’il s’agit de :

  • deux implémentations de la même chose
  • deux fichiers qui doivent être fusionnés
  • une implémentation obsolète

Ouvrez les deux versions et concevez le fichier final voulu.


32. Résoudre prudemment les conflits de renommage

Les conflits liés aux renommages peuvent impliquer :

  • renommage/renommage
  • renommage/suppression
  • renommage/modification

Vérifiez :

git status

et examinez les chemins concernés.

Ne vous fiez pas uniquement à la ressemblance des noms de fichiers ; vérifiez l’identité du fichier et sa destination prévue.


33. Comparer les modifications des branches avant de retenter un merge difficile

Après l’annulation :

git diff origin/main...feature/report-engine

et :

git log \
  --oneline \
  --graph \
  --decorate \
  origin/main \
  feature/report-engine

Utilisez ces commandes pour comprendre la divergence avant de retenter l’intégration.


34. Créer une branche de sécurité avant un travail complexe sur les conflits

git branch backup-before-conflict-resolution

C’est utile avant :

  • un rebase compliqué
  • une chirurgie manuelle sur les branches
  • un nettoyage de conflits risqué

Une référence de branche est une assurance peu coûteuse.


35. Utiliser mergetool uniquement s’il apporte de la clarté

S’il est configuré :

git mergetool

Un outil de fusion à trois voies peut afficher :

base
ours
theirs
résultat

Cela peut être plus simple que les marqueurs bruts pour les fichiers volumineux.

L’outil ne décide pas à votre place de la correction de l’application.


36. Configurer explicitement un outil de fusion

Modèle d’exemple :

git config --global merge.tool <tool-name>

La configuration exacte de l’outil dépend de l’éditeur ou de l’outil de fusion installé.

Ne copiez pas une commande d’outil à l’aveugle sans confirmer qu’elle existe dans votre environnement.


37. Utiliser l’éditeur de fusion de VS Code lorsque c’est pertinent

Si VS Code est votre éditeur configuré, les fichiers en conflit peuvent être ouverts dans son éditeur de fusion.

La même règle s’applique :

Current / Incoming / Both

sont des aides à l’édition.

Elles ne remplacent pas la compréhension du comportement final souhaité.


38. Rechercher les marqueurs de conflit avant de faire le commit

git grep -n '<<<<<<<\|=======\|>>>>>>>'

Examinez aussi le patch indexé :

git diff --cached

Cela permet de repérer les marqueurs conservés par accident.


39. Lancer le formatage seulement après la résolution sémantique

Ne laissez pas le formatage automatique masquer le conflit réel pendant que vous choisissez entre les modifications.

Ordre plus sûr :

résoudre le comportement
→ ajouter à l’index / vérifier
→ formater si nécessaire
→ vérifier le diff final
→ tester

40. Lancer les tests après la résolution

Au minimum, exécutez les contrôles pertinents pour le projet :

tests unitaires
tests d’intégration
lint
vérification des types
build

Git peut résoudre du texte.

Il ne peut pas déterminer si le comportement combiné de l’application est correct.


41. Examiner le résultat indexé exact avant de terminer

git diff --cached

Pour un commit de merge, examinez aussi :

git status

Assurez-vous que seuls les fichiers voulus sont dans l’index.


42. Ne pas inclure de nettoyage sans rapport dans la résolution des conflits

Évitez de faire en même temps :

  • le renommage de fichiers sans rapport
  • le formatage de modules entiers
  • la refactorisation du code voisin
  • la modification des dépendances

Gardez la résolution des conflits ciblée afin que le diff d’intégration reste relisible.


43. Résoudre les fichiers générés à partir de leur source lorsque c’est possible

Si un fichier généré est en conflit :

package-lock
sortie compilée
schéma généré
artefact de génération de code

commencez par comprendre le processus de génération de référence du projet.

Souvent, la bonne approche est :

résoudre la source / l’entrée
→ régénérer l’artefact

plutôt que de fusionner manuellement la sortie générée.

N’appliquez pas cela à l’aveugle aux fichiers dont l’état généré est volontairement versionné selon des règles spécifiques.


44. Gérer les conflits de fichiers de verrouillage avec le gestionnaire de paquets lorsque c’est possible

Pour les fichiers de verrouillage des dépendances, modifier manuellement les marqueurs de conflit peut facilement produire un état invalide.

Une stratégie courante consiste à :

résoudre le manifeste des dépendances
→ régénérer le fichier de verrouillage avec le bon gestionnaire de paquets / la bonne version
→ examiner le diff obtenu

Suivez le processus de gestion des dépendances documenté dans le dépôt.


45. Ne pas résoudre les conflits binaires par fusion de texte

Pour les fichiers binaires, Git ne peut pas fusionner le contenu de manière pertinente.

Choisissez la version voulue ou régénérez l’artefact.

Ajoutez ensuite le fichier résolu à l’index.


46. Surveiller les conflits sémantiques que Git ne signale pas

Exemple :

Branche A :

calculate_total(items)

La branche B modifie la signature de la fonction :

def calculate_total(items, currency):
    ...

Si les modifications ont lieu dans des fichiers différents, Git peut les fusionner sans conflit alors que le code est cassé.

Après l’intégration, lancez les tests, le build et les vérifications de types.


47. Surveiller la logique dupliquée après des merges sans conflit

Deux branches peuvent ajouter indépendamment :

gestion des nouvelles tentatives
validation
feature flags
configuration

Git peut fusionner les deux automatiquement même si le comportement combiné est redondant ou contradictoire.

Examinez le diff au niveau de la fonctionnalité, pas seulement les fichiers présentant des conflits textuels.


48. Utiliser git log --merge pendant un merge en conflit

Pendant un merge non résolu :

git log --merge --oneline

Cette commande peut aider à afficher les commits des deux côtés qui touchent les chemins en conflit.

Utilisez-la pour obtenir le contexte historique.


49. Examiner l’historique d’un fichier en conflit

git log \
  --oneline \
  -- path/to/file

Pour les patchs :

git log \
  -p \
  -- path/to/file

Utile lorsque vous devez comprendre pourquoi chaque côté a modifié le même code.


50. Utiliser blame pour le contexte historique, pas pour désigner un coupable

git blame path/to/file

Utilisez-le pour trouver les commits pertinents.

Examinez ensuite ces commits :

git show <commit>

51. Comprendre les conflits répétés pendant un rebase

Un rebase rejoue les commits un par un.

Si plusieurs commits modifient la même zone, des conflits similaires peuvent se produire plusieurs fois.

Les options sont notamment :

  • résoudre fidèlement chaque rejeu
  • annuler et réorganiser les commits privés
  • utiliser plutôt un merge si le rejeu de l’historique ajoute trop de risque

52. Activer rerere uniquement si vous le comprenez

git config rerere.enabled true

rerere peut mémoriser des résolutions de conflits précédentes et les réutiliser lorsque le même conflit réapparaît.

Vérifiez les résolutions réutilisées.

Ne supposez pas que ce qui a été mémorisé est toujours correct.


53. Afficher l’état de rerere

Lorsque rerere est activé :

git rerere status

Cela aide à identifier les fichiers pour lesquels Git enregistre ou réutilise des résolutions de conflits.


54. Privilégier des branches plus petites et plus éphémères

Des conflits importants et fréquents indiquent souvent :

  • des branches de fonctionnalité de longue durée
  • des refactorisations étendues
  • des responsabilités qui se chevauchent
  • une intégration peu fréquente

Réduire la divergence peut prévenir les conflits, plutôt que de rendre les outils de résolution toujours plus sophistiqués.


55. Intégrer séparément les refactorisations structurelles lorsque c’est possible

Si une branche :

renomme 100 fichiers

pendant qu’une autre :

modifie la logique métier de ces fichiers

les conflits deviennent plus difficiles à analyser.

Séparez les refactorisations mécaniques des changements de comportement lorsque c’est faisable.


56. Éviter de profiter de la résolution des conflits pour « tout nettoyer »

L’objectif est de préserver le comportement voulu des deux lignes de développement.

Des modifications importantes et sans rapport rendent :

  • la revue plus difficile
  • le retour arrière plus difficile
  • l’analyse des conflits plus difficile

Gardez la résolution minimale.


57. Vérifier le sens d’intégration des branches après la résolution

Pour un merge :

git log \
  --oneline \
  --graph \
  --decorate \
  -15

Confirmez que les branches attendues ont été intégrées.


58. Vérifier le diff de la fonctionnalité après un rebase

git diff origin/main...HEAD

Assurez-vous que la résolution des conflits n’a pas supprimé par accident des modifications nécessaires à la fonctionnalité.


59. Utiliser reflog si la résolution des conflits ou le travail sur l’historique tourne mal

git reflog

Retrouvez l’ancienne extrémité de la branche.

Puis :

git switch -c conflict-recovery <old-commit>

Faites-le avant toute autre modification destructive de l’historique.


60. Mettre en place une démarche reproductible de résolution des conflits

Utilisez :

1. git status
2. identifier l’opération
3. lister les fichiers non résolus
4. examiner chaque conflit
5. comprendre base/ours/theirs
6. résoudre selon le comportement voulu
7. git add sur les fichiers résolus
8. git diff --cached
9. rechercher les marqueurs de conflit
10. lancer les tests / le build
11. poursuivre ou faire le commit
12. examiner l’historique final

C’est plus sûr que de cliquer plusieurs fois sur « Accept Both » en espérant que le résultat fonctionne.

Interpréter le résultat

État/commande Signification
git status Affiche l’opération et les chemins non résolus
git diff --name-only --diff-filter=U Liste les fichiers non fusionnés
git diff Affiche le contenu des conflits non résolus
git restore --ours Prend la version du fichier du côté courant dans un état de merge applicable
git restore --theirs Prend la version du fichier du côté entrant dans un état de merge applicable
git add Marque le contenu résolu dans l’index
git merge --abort Annule le merge en cours
git rebase --continue Poursuit le rejeu après la résolution
git rebase --abort Restaure l’état antérieur au rebase
git cherry-pick --continue Poursuit le cherry-pick
git revert --continue Poursuit le revert
git ls-files -u Affiche les étapes non fusionnées de l’index
git show :1:file Ancêtre commun
git show :2:file Ours
git show :3:file Theirs

La distinction la plus importante est la suivante :

résolution textuelle des conflits
!=
correction de l’application

Points à vérifier

Le conflit apparaît dans un fichier fortement modifié par les deux branches

Examinez l’historique et l’ancêtre commun avant de résoudre.

La bonne réponse peut exiger de combiner les intentions plutôt que de choisir un côté.

Le même conflit revient plusieurs fois pendant un rebase

Plusieurs commits sont rejoués sur la même zone modifiée.

Demandez-vous si un merge ou un nettoyage de l’historique privé serait plus sûr.

ours / theirs semble inversé

Vous êtes peut-être dans un rebase ou dans une autre opération de rejeu.

Examinez le contenu réel plutôt que de vous fier aux libellés.

Le merge se termine mais les tests échouent

Recherchez des conflits sémantiques que Git n’a pas pu détecter.

Examinez les modifications dans les fichiers voisins et les interfaces.

Un nombre énorme de conflits apparaît de façon inattendue

Arrêtez-vous et vérifiez :

  • la branche courante
  • la branche entrante
  • la base de fusion (merge base)
  • si la branche a été créée à partir de la base attendue

Annuler peut être plus sûr que résoudre une mauvaise intégration.

Le conflit ne concerne que de la sortie générée

Résolvez la source de référence et régénérez lorsque le processus du dépôt le permet.

Notes de production

Un conflit est une décision d’intégration

Git signale des modifications qui se chevauchent.

Il ne peut pas déterminer quel comportement métier est correct.

La résolution des conflits doit pouvoir être relue

Gardez des résolutions ciblées et évitez les refactorisations sans rapport.

Cela rend plus sûrs la revue de la pull request et le retour arrière.

L’historique d’une branche partagée ne doit pas être réécrit simplement pour éviter de résoudre des conflits

Ne remplacez pas un merge partagé difficile par une stratégie destructive de force-push.

Préservez la sécurité de la collaboration.

Les tests font partie de la résolution des conflits

Surtout après des conflits dans :

  • les contrats d’API
  • le code de base de données
  • la configuration
  • les fichiers de build
  • les manifestes de dépendances
  • les modèles de sérialisation

Une résolution assistée par un outil exige toujours du discernement

Les boutons de l’IDE tels que :

Accept Current
Accept Incoming
Accept Both

sont des opérations d’édition, pas des décisions d’architecture.

La fréquence des conflits est un signal sur le mode de travail

Des conflits importants et répétés peuvent indiquer :

  • que les branches vivent trop longtemps
  • que des équipes modifient les mêmes modules simultanément
  • que les refactorisations sont trop étendues
  • que l’intégration a lieu trop tard

Corriger le mode de travail peut avoir plus de valeur que maîtriser les commandes de résolution des conflits.

Erreurs fréquentes

1. Choisir ours/theirs sans vérifier l’opération

Pendant un rebase, il est particulièrement facile de se tromper de modèle mental.

2. Cliquer automatiquement sur « Accept Both »

Les deux blocs peuvent dupliquer de la logique ou produire un comportement invalide.

3. Ajouter un fichier à l’index avant de vérifier la résolution

git add signifie que Git le considère comme résolu.

Vérifiez d’abord.

4. Lancer reset --hard lorsqu’un conflit apparaît

La plupart des conflits peuvent être résolus ou annulés en toute sécurité sans détruire le travail local.

5. Utiliser rebase --skip pour éviter des conflits difficiles

Cela supprime le commit rejoué.

6. Laisser des marqueurs de conflit dans le code source

Effectuez une recherche avant de faire le commit.

7. Résoudre manuellement des fichiers générés sans vérifier le processus de génération

La régénération peut être plus sûre et reproductible.

8. Considérer un merge Git sans conflit comme une fusion correcte de l’application

Des conflits sémantiques peuvent subsister.

9. Mélanger une refactorisation sans rapport avec la résolution

Cela rend la revue et le retour arrière plus difficiles.

10. Poursuivre avant d’avoir traité tous les chemins non résolus

Utilisez git status et la requête sur les fichiers non fusionnés pour vérifier.

Étape suivante

Utilisez l’opération et le symptôme pour choisir l’action suivante.

  • Conflit de merge normal → résolvez les fichiers, ajoutez-les à l’index, vérifiez, testez, puis faites le commit.
  • Conflit de rebase → résolvez, ajoutez à l’index, puis git rebase --continue.
  • Conflit de cherry-pick → résolvez, ajoutez à l’index, puis git cherry-pick --continue.
  • Conflit de revert → résolvez la modification inverse voulue, puis git revert --continue.
  • Mauvaise branche ou mauvais sens d’intégration → annulez l’opération.
  • ours/theirs prête à confusion → examinez les étapes de l’index et le contenu réel des fichiers.
  • Conflits sur des fichiers générés ou de verrouillage → résolvez les entrées de référence et régénérez lorsque c’est approprié.
  • Conflits étonnamment massifs → examinez le graphe des branches et la base de fusion avant de continuer.
  • Git ne signale aucun conflit mais les tests échouent → recherchez des conflits sémantiques.
  • Vous pensez que le travail sur les conflits a endommagé l’historique → examinez git reflog et créez une branche de récupération avant toute autre modification.

← Tous les aide-mémoire