Git merge et conflits : le guide complet pour débutant

Avec Git, les merges et les conflits finissent toujours par arriver. Et la première fois qu’un message “CONFLICT” apparaît dans le terminal, on a souvent l’impression d’avoir complètement cassé son projet. Pourtant, dans la majorité des cas, il s’agit simplement d’un problème de fusion que Git vous demande de résoudre manuellement.

Dans ce tutoriel Git, vous allez comprendre comment fonctionne un git merge, pourquoi les conflits apparaissent, et surtout comment les corriger étape par étape. Que vous travailliez seul ou en équipe, vous apprendrez à fusionner vos branches proprement, à lire les messages de Git et à résoudre les conflits de manière simple et logique, même si vous débutez complètement.

• Les conflits Git apparaissent et arrêter de paniquer devant un terminal rempli de messages incompréhensibles.
• Apprendre à fusionner des branches proprement avec git merge pour travailler plus sereinement sur vos projets web.
• Savoir lire et corriger un conflit étape par étape afin d’éviter les erreurs qui bloquent souvent les débutants avec Git.

Uun conflit Git n’est ni rare, ni grave. Au contraire, c’est même un fonctionnement totalement normal lorsque plusieurs modifications se croisent. Une fois que vous aurez compris comment Git fusionne les branches et pourquoi un conflit apparaît, vous verrez que tout devient beaucoup plus logique.

Comprendre le rôle du merge dans Git

Avant de parler des conflits, il faut déjà comprendre ce qu’est un merge.

Dans Git, un merge permet de fusionner le contenu de deux branches.

En général, cela sert à récupérer le travail réalisé sur une branche secondaire pour l’ajouter à la branche principale.

Imaginez par exemple ce scénario :

• vous avez une branche main qui contient votre site stable,
• vous créez une branche nouveau-menu,
• vous modifiez plusieurs fichiers,
• puis vous souhaitez intégrer ces changements dans main.

C’est exactement le rôle de git merge.

👉 Tout savoir sur les Branches Git.

Pourquoi utiliser des branches ?

Les branches sont extrêmement importantes dans Git. Elles permettent de travailler sans casser le projet principal.

Prenons un exemple concret : Vous développez un site vitrine pour un client. Le site fonctionne déjà correctement, mais vous voulez tester une nouvelle bannière d’accueil.

Au lieu de modifier directement la branche principale, vous créez une branche dédiée :

git checkout -b nouvelle-banniere

Cette commande crée une nouvelle branche et vous place dessus immédiatement.

Vous pouvez alors modifier vos fichiers librement, tester des idées, faire des erreurs, recommencer… sans toucher à la version stable du projet.

Une fois votre travail terminé, vous pourrez fusionner cette branche avec main.

Comment fonctionne un merge dans Git

Prenons un exemple très simple.

Vous avez la branche principale :

main

Puis vous créez une branche :

feature-contact

Sur cette branche, vous ajoutez une page de contact.

Ensuite, vous revenez sur main :

git checkout main

Puis vous lancez le merge :

git merge feature-contact

Git va alors comparer les deux branches et intégrer les différences.

Dans le meilleur des cas, tout se passe automatiquement.

Git affiche alors quelque chose comme :

Updating 8f3a1c2..d7f9b11
Fast-forward

Et là, c’est parfait. Aucun conflit.

Le fameux “Fast-forward”

Quand Git affiche “Fast-forward”, cela signifie qu’aucune modification concurrente n’existe. En réalité, Git avance simplement le pointeur de la branche principale.

Imaginez une route toute droite :

A --- B --- C

Puis une branche :

A --- B --- C --- D

Si main n’a pas changé pendant votre travail, Git peut avancer directement vers D.

C’est simple, propre et automatique.

Quand un conflit apparaît-il ?

Les conflits arrivent lorsque Git ne sait plus quelle version conserver.

Le cas le plus fréquent est celui-ci :

• deux personnes modifient la même ligne d’un fichier,
• ou vous modifiez un fichier sur deux branches différentes,
• puis vous essayez de fusionner le tout.

Git se retrouve alors dans une situation compliquée :

“Quelle version dois-je garder ?”

Et comme Git préfère éviter de détruire du code sans votre accord, il vous demande de choisir manuellement.

Exemple concret de conflit Git

Imaginons un fichier nommé :

index.html

Son contenu initial :

<h1>Bienvenue sur mon site</h1>

Modification sur la branche main

Vous modifiez le texte :

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

Puis vous faites un commit.

Modification sur une autre branche

Sur une branche secondaire, vous changez la même ligne :

<h1>Bienvenue sur le site de démonstration</h1>

Vous faites également un commit.

Et maintenant… Vous essayez de fusionner les deux branches.

Git détecte que les deux versions modifient exactement la même ligne.

Résultat :

CONFLICT (content): Merge conflict in index.html
Automatic merge failed

Pas de panique. Le projet n’est pas cassé.

• Git attend simplement votre décision.

Comment reconnaître un fichier en conflit

Lorsque Git rencontre un conflit, il modifie directement le fichier concerné.

En ouvrant le fichier, vous verrez ceci :

<<<<<<< HEAD
<h1>Bienvenue sur notre site officiel</h1>
=======
<h1>Bienvenue sur le site de démonstration</h1>
>>>>>>> feature-demo

La première fois qu’on voit ça, on peut avoir un léger moment de solitude.

Pourtant, c’est très simple à lire.

Comprendre les marqueurs de conflit

Git ajoute des séparateurs spéciaux.

La partie HEAD

<<<<<<< HEAD

Cette zone représente la version actuelle de votre branche.

Ici :

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

Le séparateur

=======

Il sépare les deux versions.

La branche fusionnée

>>>>>>> feature-demo

Cette partie correspond au contenu provenant de l’autre branche.

Comment résoudre un conflit Git

Résoudre un conflit consiste simplement à modifier le fichier pour garder le bon contenu.

Vous pouvez :

• conserver la première version,
• conserver la seconde,
• ou fusionner les deux manuellement.

Par exemple :

<h1>Bienvenue sur notre site officiel de démonstration</h1>

Ensuite, vous supprimez tous les marqueurs :

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

Le fichier doit redevenir parfaitement normal.

Étape finale après la résolution

Une fois le fichier corrigé, Git considère encore le conflit comme “non terminé”.

Vous devez donc indiquer que le problème est résolu.

Ajouter le fichier

git add index.html

Finaliser le merge

git commit

Git ouvrira parfois automatiquement un message de commit.

Vous pouvez conserver le message proposé :

Merge branch 'feature-demo'

Et voilà.

• Le conflit est résolu.

Vérifier les fichiers en conflit

Quand plusieurs fichiers sont concernés, il devient important de savoir lesquels posent problème.

La commande suivante est très utile :

git status

Git affichera :

Des formations informatique pour tous !

Débutant ou curieux ? Apprenez le développement web, le référencement, le webmarketing, la bureautique, à maîtriser vos appareils Apple et bien plus encore…

Formateur indépendant, professionnel du web depuis 2006, je vous accompagne pas à pas et en cours particulier, que vous soyez débutant ou que vous souhaitiez progresser. En visio, à votre rythme, et toujours avec pédagogie.

Découvrez mes formations Qui suis-je ?

Unmerged paths:

Puis la liste des fichiers concernés.

Exemple :

both modified: index.html
both modified: style.css

C’est un peu le tableau de bord des conflits.

Une méthode simple pour résoudre un conflit

Quand on débute, il est facile de se sentir dépassé.

Voici une méthode très rassurante :

Étape 1 : lancer le merge

git merge ma-branche

Étape 2 : regarder les fichiers concernés

git status

Étape 3 : ouvrir les fichiers

Cherchez :

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

Étape 4 : choisir le bon contenu

Supprimez les marqueurs.

Étape 5 : ajouter les fichiers corrigés

git add .

Étape 6 : terminer le merge

git commit

Et c’est terminé.

Avec l’habitude, cette procédure devient presque automatique.

Utiliser un éditeur pour mieux visualiser les conflits

Vous n’êtes pas obligé de tout faire “à la main” depuis le terminal.

Des éditeurs modernes comme Visual Studio Code simplifient énormément la résolution des conflits. Quand un conflit apparaît, VS Code affiche des boutons très pratiques :

• Accept Current Change
• Accept Incoming Change
• Accept Both Changes

Vous pouvez donc résoudre un conflit en quelques clics sans modifier manuellement les marqueurs.

C’est particulièrement rassurant lorsqu’on débute.

Comprendre la logique derrière les conflits

Beaucoup de débutants pensent :

“Git est compliqué.”

En réalité, Git est surtout très prudent.

Imaginez deux personnes écrivant dans le même document Word exactement au même endroit. Comment un logiciel pourrait-il deviner automatiquement quelle version est correcte ?

• Git préfère donc vous laisser décider.

Et honnêtement, c’est plutôt une bonne chose.

Éviter les conflits Git

Même si les conflits sont normaux, il existe plusieurs bonnes pratiques pour les limiter.

Faire des commits réguliers

Plus vos modifications sont petites, plus les merges sont simples.

Un énorme commit de 300 fichiers est souvent une catastrophe annoncée.

À l’inverse, des commits fréquents rendent les conflits beaucoup plus faciles à comprendre.

Récupérer régulièrement les mises à jour

Si vous travaillez en équipe, pensez à mettre votre branche à jour souvent.

Par exemple :

git pull origin main

Cela évite de découvrir 500 changements au moment du merge final.

Éviter de modifier les mêmes zones

En équipe, essayez de répartir les tâches intelligemment.

Si deux développeurs travaillent exactement sur le même composant, les conflits deviennent quasiment inévitables.

Différence entre merge et rebase

Quand on apprend Git, on entend souvent parler de merge et rebase.

Les deux servent à intégrer des modifications, mais leur logique est différente.

Le merge

Le merge conserve l’historique réel.

Git crée un commit de fusion.

C’est souvent la méthode la plus simple et la plus sûre pour les débutants.

Le rebase

Le rebase réécrit l’historique.

Cela peut produire un historique plus propre, mais aussi plus complexe à comprendre.

Pour débuter, mieux vaut déjà maîtriser parfaitement merge avant de se lancer dans les subtilités du rebase.

Annuler un merge en cours

Parfois, on démarre un merge… puis on réalise qu’on s’est trompé.

Heureusement, Git permet d’annuler l’opération.

git merge --abort

Cette commande annule le merge et remet le projet dans son état précédent.

Très pratique quand on commence à paniquer devant 47 conflits simultanés.

Oui, ça arrive plus souvent qu’on ne le pense.

Les conflits ne sont pas des erreurs

C’est probablement le point le plus important de cet article.

• Un conflit Git n’est pas un bug.
• Ce n’est pas un plantage.
• Et ce n’est certainement pas une catastrophe.

C’est simplement Git qui vous demande :

“Quelle version souhaitez-vous conserver ?”

Avec l’expérience, les conflits deviennent même des situations très banales du quotidien.

Exemple complet

Prenons maintenant un scénario entier.

Création du projet

git init

Création d’un fichier

echo "Bonjour" > texte.txt

Premier commit

git add .
git commit -m "Premier commit"

Création d’une branche

git checkout -b modification-texte

Modification sur la branche

echo "Bonjour à tous" > texte.txt

Commit :

git add .
git commit -m "Modification branche secondaire"

Retour sur main

git checkout main

Nouvelle modification

echo "Bonjour le monde" > texte.txt

Commit :

git add .
git commit -m "Modification sur main"

Merge

git merge modification-texte

Git affiche :

CONFLICT (content)

Ouverture du fichier

<<<<<<< HEAD
Bonjour le monde
=======
Bonjour à tous
>>>>>>> modification-texte

Résolution manuelle

Bonjour à tous et bienvenue

Validation

git add texte.txt
git commit

Le conflit est maintenant résolu proprement.

Apprendre les conflits est important

Beaucoup de développeurs débutants essaient d’éviter les conflits Git pendant des mois. Pourtant, savoir les résoudre est une compétence essentielle.

Dès que vous travaillerez :

• en équipe,
• sur plusieurs fonctionnalités,
• avec plusieurs branches,
• ou sur un projet professionnel,

vous rencontrerez forcément des merges complexes.

Et plus tôt vous serez à l’aise avec ça, plus vous gagnerez en sérénité.

Les outils graphiques peuvent aider

Si la ligne de commande vous impressionne encore, sachez qu’il existe des interfaces graphiques très accessibles.

Par exemple :

• GitHub Desktop
• Sourcetree
• GitKraken

Ces outils affichent souvent les conflits de manière visuelle avec des comparaisons côte à côte. C’est parfois beaucoup plus confortable lorsqu’on débute.

Cela dit, comprendre les bases en ligne de commande reste extrêmement utile.

---

FAQ Merge et conflit

---

Les conflits Git font peur uniquement jusqu’au moment où l’on comprend leur fonctionnement. Après cela, tout devient beaucoup plus logique.

Le plus important est de retenir qu’un conflit n’est pas une erreur grave. Git essaie simplement de protéger votre travail en vous laissant choisir la bonne version du code.

Au début, vous devrez probablement relire plusieurs fois les fichiers concernés et réfléchir avant de valider vos modifications. C’est parfaitement normal. Même les développeurs expérimentés prennent parfois quelques minutes pour analyser un merge compliqué.

La meilleure façon de progresser reste la pratique. Créez deux branches de test, modifiez volontairement les mêmes lignes, provoquez des conflits et entraînez-vous à les résoudre. Plus vous manipulerez Git, plus ces situations deviendront naturelles.

Et un jour, vous repenserez à votre premier “CONFLICT” avec un petit sourire. Probablement accompagné d’un léger traumatisme… mais surtout avec beaucoup plus de confiance.

👉 Pour aller plus loin : Restauration fichier ou version et correction d’erreur avec Git.