Comprendre et résoudre les conflits Git

Introduction

Dans les tutoriels précédents, nous avons découvert progressivement les principales commandes de Git.

Nous avons appris à créer un dépôt Git, enregistrer des modifications avec des commits, envoyer notre projet sur GitHub, récupérer un dépôt distant, créer des branches avec git branch et git switch, puis fusionner ces branches avec git merge.

Dans le tutoriel précédent, la fusion de notre branche nouvelle-page avec main s’est déroulée automatiquement grâce à une fusion fast-forward.

Cependant, toutes les fusions ne sont pas aussi simples.

Lorsque deux branches modifient différemment la même partie d’un fichier, Git peut ne pas savoir quelle modification conserver.

Git signale alors un conflit.

Dans ce dernier tutoriel consacré à Git, nous allons volontairement créer un conflit afin de comprendre son fonctionnement et apprendre à le résoudre.

Nous allons découvrir :

• ce qu’est un conflit Git ;
• pourquoi un conflit peut apparaître ;
• comment provoquer volontairement un conflit ;
• comment identifier les fichiers concernés ;
• comment comprendre les marqueurs de conflit ;
• comment choisir la modification à conserver ;
• comment terminer correctement une fusion après la résolution du conflit ;
• comment vérifier l’historique final.

Nous allons continuer à utiliser le dossier mon-projet des tutoriels précédents.

1. Qu’est-ce qu’un conflit Git ?

Un conflit Git apparaît lorsque Git ne peut pas déterminer automatiquement comment réunir certaines modifications.

Imaginons que deux branches possèdent initialement cette ligne dans index.html :

<h1>Bienvenue sur mon site</h1>

Sur une première branche, cette ligne devient :

<h1>Bienvenue sur notre nouveau site</h1>

Pendant ce temps, sur une autre branche, la même ligne devient :

<h1>Bienvenue sur SysNetTuto</h1>

Git possède maintenant deux modifications différentes pour le même emplacement du fichier.

Lors de la fusion, Git ne peut pas décider à notre place laquelle doit être conservée.

Il interrompt donc temporairement la fusion et nous demande de résoudre le conflit.

Un conflit n’est donc pas nécessairement une erreur.

Il signifie simplement qu’une intervention humaine est nécessaire pour déterminer le contenu final.

2. Dans quelles situations un conflit apparaît-il ?

Un conflit peut notamment apparaître lorsque plusieurs branches modifient différemment la même partie d’un fichier.

Par exemple, nous pouvons avoir au départ :

Puis créer une nouvelle branche.

Les deux branches évoluent ensuite séparément :

Les commits D et E contiennent ici des modifications différentes de la même ligne de index.html.

Lorsque nous tenterons de réunir les deux branches, Git détectera qu’il ne peut pas choisir automatiquement entre les deux versions.

Nous allons reproduire cette situation.

3. Reprendre mon-projet

Nous allons reprendre le projet utilisé dans les tutoriels précédents.

Placez-vous dans le dossier :

cd mon-projet

Vérifiez ensuite l’état du dépôt :

git status

Avant de commencer, il est préférable que le dépôt ne possède aucune modification en attente.

Vous pouvez également vérifier la branche actuelle avec :

git branch

Nous allons commencer depuis main.

Si vous êtes sur une autre branche, utilisez :

git switch main

Vérifiez de nouveau :

git branch

L’astérisque doit apparaître devant main.

4. Créer modification-accueil

Nous allons créer une nouvelle branche destinée à modifier le titre de notre page d’accueil.

Depuis main, utilisez :

git switch -c modification-accueil

Cette commande effectue deux opérations :

• elle crée la branche modification-accueil ;
• elle bascule immédiatement dessus.

Vérifiez avec :

git branch

Vous devriez maintenant voir main et modification-accueil, avec l’astérisque devant modification-accueil.

Notre nouvelle branche part exactement de l’état actuel de main.

5. Modifier index.html sur la nouvelle branche

Nous allons maintenant modifier index.html.

Le fichier existe déjà dans notre projet : il n’est donc pas nécessaire de le recréer.

Ouvrez-le avec votre éditeur de texte.

Sous Linux, vous pouvez par exemple utiliser :

nano index.html

Repérez le titre principal de la page.

Pour notre exemple, nous allons utiliser :

<h1>Bienvenue sur notre nouveau site</h1>

Enregistrez ensuite le fichier.

Git devrait détecter la modification.

Vérifiez avec :

git status

Le fichier index.html doit apparaître comme modifié.

6. Enregistrer la modification

Nous allons enregistrer cette première version dans l’historique de modification-accueil.

Ajoutez le fichier à la zone de préparation :

git add index.html

Puis créez un commit :

git commit -m "Modification du titre de la page d'accueil"

Vérifiez ensuite :

git status

Le dépôt devrait de nouveau être propre.

Nous avons maintenant une modification enregistrée uniquement dans la branche modification-accueil.

7. Revenir sur main

Nous allons maintenant revenir sur la branche principale :

git switch main

Git remet le dossier de travail dans l’état correspondant à main.

Vérifiez la branche actuelle :

git branch

L’astérisque doit maintenant apparaître devant main.

À ce stade, la modification réalisée dans modification-accueil n’est pas encore présente dans main.

8. Modifier la même ligne différemment

Nous allons maintenant provoquer volontairement notre conflit.

Ouvrez de nouveau index.html :

nano index.html

Nous allons modifier exactement la même ligne que celle modifiée sur modification-accueil, mais avec un contenu différent.

Sur main, utilisez par exemple :

<h1>Bienvenue sur SysNetTuto</h1>

Nous avons donc maintenant deux versions différentes.

Sur modification-accueil :

<h1>Bienvenue sur notre nouveau site</h1>

Et sur main :

<h1>Bienvenue sur SysNetTuto</h1>

Enregistrez le fichier.

9. Enregistrer la modification sur main

Vérifiez tout d’abord la modification :

git status

Ajoutez ensuite index.html :

git add index.html

Puis créez un commit :

git commit -m "Mise à jour du titre de la page d'accueil"

Nous avons maintenant deux commits différents contenant chacun une modification de la même ligne.

Vérifiez que le dépôt est propre :

git status

Nous sommes prêts à provoquer le conflit.

10. Visualiser les deux historiques

Avant de lancer la fusion, observons l’historique :

git log --oneline --graph --all

Vous devriez constater que les deux branches ont évolué séparément.

La situation peut être représentée simplement ainsi :

Le commit D contient la première modification du titre.

Le commit E contient la deuxième modification du même titre.

Les deux branches possèdent donc maintenant des historiques différents.

Contrairement au tutoriel précédent, une fusion fast-forward n’est plus possible.

11. Lancer git merge modification-accueil

Nous sommes actuellement sur main.

C’est cette branche qui doit recevoir le travail de modification-accueil.

Lancez :

git merge modification-accueil

Cette fois, Git ne devrait pas pouvoir terminer automatiquement la fusion.

Vous devriez obtenir un message similaire à :

Git indique qu’un conflit a été détecté dans index.html.

La fusion est maintenant en cours, mais elle n’est pas terminée.

12. Comprendre le message CONFLICT

Le message CONFLIT (contenu) : Conflit de fusion dans index.html nous indique que Git a rencontré un conflit de contenu dans index.html.

Vérifiez l’état du dépôt :

git status

Git devrait indiquer que index.html contient des modifications non fusionnées.

À ce stade, il ne faut pas relancer immédiatement git merge.

Nous devons d’abord ouvrir le fichier concerné et résoudre manuellement le conflit.

13. Examiner les marqueurs <<<<<<<, ======= et >>>>>>>

Ouvrez index.html :

nano index.html

Git a ajouté des marqueurs directement dans le fichier.

Vous devriez retrouver une structure similaire à :

Ces marqueurs permettent d’identifier les deux versions en conflit.

La partie située entre :

<<<<<<< HEAD
...
=======

correspond à la version de la branche sur laquelle nous nous trouvons actuellement.

Dans notre cas, il s’agit de main.

Nous avons donc :

<h1>Bienvenue sur SysNetTuto</h1>

La partie située entre :

=======
...
>>>>>>> modification-accueil

correspond à la modification provenant de la branche que nous essayons de fusionner.

Ici :

<h1>Bienvenue sur notre nouveau site</h1>

Git nous présente les deux versions, mais c’est à nous de choisir le résultat final.

14. Choisir la version à conserver

Pour résoudre le conflit, nous devons modifier manuellement le fichier.

Nous pouvons conserver la version de main :

<h1>Bienvenue sur SysNetTuto</h1>

Nous pouvons conserver celle de modification-accueil :

<h1>Bienvenue sur notre nouveau site</h1>

Nous pouvons également écrire une troisième version combinant les deux idées.

Pour notre exemple, nous allons conserver :

<h1>Bienvenue sur SysNetTuto</h1>

Le fichier doit donc être nettoyé afin de ne conserver que le contenu souhaité.

Les marqueurs suivants doivent être entièrement supprimés :

<<<<<<< HEAD
=======
>>>>>>> modification-accueil

Après la résolution, la partie concernée de index.html doit simplement contenir :

<h1>Bienvenue sur SysNetTuto</h1>

Enregistrez le fichier.

15. Terminer la résolution avec git add et git commit

Nous avons corrigé le fichier, mais Git ne sait pas encore que nous considérons le conflit comme résolu.

Vérifiez :

git status

Nous devons maintenant indiquer à Git que index.html a été résolu.

Utilisez :

git add index.html

Puis vérifiez de nouveau :

git status

Git doit maintenant considérer le conflit comme résolu, mais la fusion doit encore être finalisée.

Créez le commit de fusion :

git commit -m "Résolution du conflit sur index.html"

La fusion est maintenant terminée.

16. Vérifier que la fusion est terminée

Utilisez :

git status

Si tout s’est correctement déroulé, Git devrait indiquer que le dépôt est propre.

Par exemple :

Nous pouvons également vérifier le contenu final de index.html.

Par exemple :

cat index.html

Le fichier ne doit surtout plus contenir les marqueurs :

<<<<<<<
=======
>>>>>>>

Il doit uniquement contenir la version que nous avons décidé de conserver.

17. Visualiser l’historique final

Affichez maintenant l’historique complet :

git log --oneline --graph --all

Cette fois, vous devriez voir les deux historiques se rejoindre grâce au commit de fusion.

Une représentation simplifiée peut ressembler à :

D représente le commit réalisé sur modification-accueil.

E représente le commit réalisé sur main.

F représente le commit créé après la résolution du conflit et la finalisation de la fusion.

Git conserve ainsi l’historique des modifications réalisées sur les deux branches.

18. Supprimer la branche fusionnée

Maintenant que modification-accueil a été correctement fusionnée dans main, nous n’avons plus nécessairement besoin de cette branche.

Vérifiez d’abord que vous êtes sur main :

git branch

Puis supprimez la branche :

git branch -d modification-accueil

Git devrait accepter la suppression puisque son travail fait désormais partie de l’historique de main.

Vérifiez :

git branch

Il ne devrait rester que main, sauf si votre projet contient d’autres branches.

Le travail réalisé sur modification-accueil n’est pas perdu : ses commits sont toujours présents dans l’historique.

Conclusion de la série Git

Dans ce tutoriel, nous avons volontairement créé un conflit Git afin de comprendre comment le détecter et le résoudre.

Nous avons créé une branche :

git switch -c modification-accueil

Puis nous avons modifié la même ligne de index.html différemment sur modification-accueil et sur main.

Lorsque nous avons lancé :

git merge modification-accueil

Git n’a pas pu choisir automatiquement entre les deux versions et a signalé un conflit.

Nous avons alors découvert les marqueurs :

<<<<<<< HEAD
=======
>>>>>>> modification-accueil

Après avoir choisi la version à conserver et supprimé ces marqueurs, nous avons indiqué à Git que le conflit était résolu :

git add index.html

Puis nous avons terminé la fusion avec :

git commit -m "Résolution du conflit sur index.html"

Enfin, nous avons vérifié l’historique avec :

git log --oneline --graph --all

et supprimé la branche devenue inutile :

git branch -d modification-accueil

Ce tutoriel termine notre série consacrée aux bases de Git.

Au fil de cette série, nous avons appris à installer et utiliser Git, créer un dépôt, suivre les modifications d’un projet, créer des commits, travailler avec GitHub, envoyer et récupérer du code, utiliser des branches, les fusionner et enfin résoudre les conflits pouvant apparaître lors d’une fusion.

Vous disposez maintenant des bases essentielles pour utiliser Git dans vos propres projets et commencer à travailler avec un véritable historique de versions.