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