Comment résoudre l'erreur 'Your local changes would be overwritten by merge' dans Git

GitGitBeginner
Pratiquer maintenant

💡 Ce tutoriel est traduit par l'IA à partir de la version anglaise. Pour voir la version originale, vous pouvez cliquer ici

Introduction

Git est un puissant système de contrôle de version qui aide les développeurs à gérer leur code et à collaborer efficacement. Cependant, vous pouvez parfois rencontrer des messages d'erreur qui peuvent être déroutants, surtout lorsque vous débutez avec Git. Une erreur courante est "Your local changes would be overwritten by merge." Cette erreur se produit lorsque Git ne peut pas fusionner les modifications en toute sécurité car cela écraserait vos modifications locales non validées.

Dans ce lab, vous apprendrez ce qui cause cette erreur, comment la résoudre et comment mettre en œuvre des stratégies pour empêcher cette erreur de se produire dans vos futurs flux de travail Git.

Comprendre le flux de travail Git

Avant de nous plonger dans la résolution des conflits de fusion (merge conflicts), comprenons le flux de travail Git de base et configurons notre environnement pour démontrer l'erreur.

Qu'est-ce que Git

Git est un système de contrôle de version distribué qui permet à plusieurs développeurs de travailler sur la même base de code sans interférer avec le travail de chacun. Il garde une trace des modifications apportées aux fichiers au fil du temps, vous permettant de revenir aux versions précédentes si nécessaire.

Flux de travail Git de base

Un flux de travail Git typique implique les étapes suivantes :

  1. Modification des fichiers dans votre répertoire de travail (working directory)
  2. Préparation des modifications avec git add
  3. Validation des modifications avec git commit
  4. Envoi des modifications vers un dépôt distant (remote repository) avec git push
  5. Récupération des modifications d'un dépôt distant avec git pull

Commençons

Tout d'abord, naviguez vers notre répertoire de projet :

cd /home/labex/project/git-merge-demo

Vérifions l'état de notre dépôt :

git status

Vous devriez voir une sortie similaire à :

On branch main
nothing to commit, working tree clean

Maintenant, vérifions quelles branches nous avons :

git branch

Vous devriez voir :

  development
* main

L'astérisque (*) indique que vous êtes actuellement sur la branche main. Examinons les fichiers de notre dépôt :

ls -la

Vous devriez voir :

total 20
drwxr-xr-x 3 labex labex 4096 ... .
drwxr-xr-x 3 labex labex 4096 ... ..
drwxr-xr-x 8 labex labex 4096 ... .git
-rw-r--r-- 1 labex labex   24 ... README.md
-rw-r--r-- 1 labex labex   27 ... script.js
-rw-r--r-- 1 labex labex   25 ... styles.css

Regardons le contenu de ces fichiers :

cat README.md
cat script.js
cat styles.css

Parfait ! Maintenant, vous comprenez la structure de notre dépôt. Dans l'étape suivante, nous allons créer un scénario qui génère l'erreur "local changes would be overwritten by merge".

Création d'un scénario de conflit de fusion

Dans cette étape, nous allons créer un scénario qui conduit à l'erreur "Your local changes would be overwritten by merge". Cela vous aidera à comprendre pourquoi cette erreur se produit.

Effectuer des modifications sur la branche de développement

Tout d'abord, passons à la branche development et effectuons quelques modifications :

git checkout development

Vous devriez voir :

Switched to branch 'development'

Maintenant, modifions le fichier script.js :

echo "console.log('Hello from development branch!');" > script.js

Validons cette modification :

git add script.js
git commit -m "Update script.js on development branch"

Vous devriez voir :

[development xxxxxxx] Update script.js on development branch
 1 file changed, 1 insertion(+), 1 deletion(-)

Effectuer des modifications non validées sur la branche principale

Maintenant, revenons à la branche main :

git checkout main

Vérifions que nous sommes sur la branche principale :

git branch

Vous devriez voir :

  development
* main

Maintenant, modifions le même fichier (script.js) sur la branche main, mais cette fois, nous ne validerons pas les modifications :

echo "console.log('Hello from main branch!');" > script.js

Déclencher l'erreur de conflit de fusion

Maintenant que nous avons des modifications non validées dans notre répertoire de travail, essayons de fusionner la branche development dans la branche main :

git merge development

Vous devriez voir un message d'erreur similaire à :

error: Your local changes to the following files would be overwritten by merge:
        script.js
Please commit your changes or stash them before you merge.
Aborting

Félicitations ! Vous avez réussi à créer un scénario qui génère l'erreur "Your local changes would be overwritten by merge".

Cette erreur se produit parce que :

  1. Vous avez modifié script.js sur la branche development et validé les modifications.
  2. Vous avez également modifié script.js sur la branche main mais n'avez pas validé les modifications.
  3. En essayant de fusionner, Git a détecté que vos modifications non validées seraient écrasées par l'opération de fusion.

Dans l'étape suivante, nous allons apprendre à résoudre cette erreur.

Résoudre le conflit de fusion avec Git Stash

L'une des façons les plus courantes et utiles de résoudre l'erreur "Your local changes would be overwritten by merge" est d'utiliser git stash. La commande git stash enregistre temporairement vos modifications non validées afin que vous puissiez les appliquer plus tard.

Qu'est-ce que Git Stash

git stash est une commande Git qui prend vos modifications non validées (staged et unstaged), les enregistre pour une utilisation ultérieure, puis annule les modifications dans votre copie de travail.

Utiliser Git Stash pour résoudre l'erreur

Utilisons git stash pour enregistrer nos modifications non validées :

git stash

Vous devriez voir une sortie similaire à :

Saved working directory and index state WIP on main: xxxxxxx Initial commit

Ce message confirme que vos modifications ont été enregistrées. Vérifions que notre répertoire de travail est maintenant propre :

git status

Vous devriez voir :

On branch main
nothing to commit, working tree clean

Vérifions maintenant le contenu de script.js :

cat script.js

Vous devriez voir le contenu original :

console.log('Hello, Git!');

Fusionner la branche de développement

Maintenant que notre répertoire de travail est propre, nous pouvons fusionner en toute sécurité la branche development :

git merge development

Vous devriez voir :

Updating xxxxxxx..xxxxxxx
Fast-forward
 script.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

Vérifions à nouveau le contenu de script.js :

cat script.js

Maintenant, vous devriez voir :

console.log('Hello from development branch!');

Récupérer vos modifications stashed

Maintenant que nous avons réussi à fusionner la branche development, récupérons nos modifications stashed :

git stash list

Vous devriez voir :

stash@{0}: WIP on main: xxxxxxx Initial commit

Cela montre que nous avons un stash enregistré. Appliquons-le :

git stash apply

Vous pourriez voir un message de conflit :

Auto-merging script.js
CONFLICT (content): Merge conflict in script.js

Ceci est normal car Git essaie d'appliquer vos modifications stashed par-dessus le fichier fusionné. Vérifions le contenu de script.js :

cat script.js

Vous devriez voir quelque chose comme :

<<<<<<< Updated upstream
console.log('Hello from development branch!');
=======
console.log('Hello from main branch!');
>>>>>>> Stashed changes

Il s'agit d'un conflit de fusion que vous devez résoudre manuellement. Ouvrez le fichier en utilisant nano :

nano script.js

Modifiez le fichier pour conserver les deux modifications ou en choisir une :

// Keep both changes
console.log("Hello from development branch!");
console.log("Hello from main branch!");

Enregistrez le fichier en appuyant sur Ctrl+O, puis sur Entrée, et quittez nano en appuyant sur Ctrl+X.

Maintenant, préparons et validons le conflit résolu :

git add script.js
git commit -m "Merge development branch and resolve conflict"

Félicitations ! Vous avez réussi à résoudre l'erreur "Your local changes would be overwritten by merge" en utilisant git stash.

Autres méthodes pour résoudre l'erreur de fusion

Dans l'étape précédente, nous avons utilisé git stash pour résoudre l'erreur "Your local changes would be overwritten by merge". Dans cette étape, nous allons explorer d'autres approches pour gérer cette situation.

Méthode 1 : Valider vos modifications avant la fusion

L'une des façons les plus simples d'éviter l'erreur "Your local changes would be overwritten by merge" est de valider vos modifications avant d'effectuer une opération de fusion.

Créons un autre scénario pour le démontrer. Tout d'abord, modifions le fichier styles.css :

echo "body { background-color: #f0f0f0; }" > styles.css

Maintenant, au lieu de stasher nos modifications, validons-les :

git add styles.css
git commit -m "Update styles.css on main branch"

Vous devriez voir :

[main xxxxxxx] Update styles.css on main branch
 1 file changed, 1 insertion(+), 1 deletion(-)

Maintenant, passons à la branche development, effectuons une modification sur le même fichier et validons-la :

git checkout development
echo "body { background-color: #e0e0e0; }" > styles.css
git add styles.css
git commit -m "Update styles.css on development branch"

Maintenant, revenons à la branche main :

git checkout main

Si nous essayons de fusionner maintenant, il n'y aura pas d'erreur "local changes would be overwritten" car nous avons validé nos modifications. Cependant, nous pourrions rencontrer un conflit de fusion :

git merge development

Vous pourriez voir :

Auto-merging styles.css
CONFLICT (content): Merge conflict in styles.css
Automatic merge failed; fix conflicts and then commit the result.

Il s'agit d'un type de conflit différent qui se produit lorsque les deux branches ont validé des modifications sur les mêmes parties d'un fichier. Résolvons ce conflit :

cat styles.css

Vous devriez voir :

<<<<<<< HEAD
body { background-color: #f0f0f0; }
=======
body { background-color: #e0e0e0; }
>>>>>>> development

Modifions le fichier pour résoudre le conflit :

nano styles.css

Changez le contenu en :

body {
  background-color: #f5f5f5;
}

Enregistrez le fichier et validez le conflit résolu :

git add styles.css
git commit -m "Resolve merge conflict in styles.css"

Méthode 2 : Utiliser Git Checkout pour annuler les modifications locales

Une autre approche consiste simplement à annuler vos modifications locales si vous n'en avez plus besoin :

## Create a change to README.md
echo "## Updated README" > README.md

## Check the status
git status

Vous devriez voir :

On branch main
Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git checkout -- <file>..." to discard changes in working directory)

        modified:   README.md

no changes added to commit (use "git add" and/or "git commit -a")

Si vous décidez que vous n'avez pas besoin de ces modifications, vous pouvez les annuler :

git checkout -- README.md

Vérifions à nouveau le statut :

git status

Vous devriez voir :

On branch main
nothing to commit, working tree clean

Et le contenu de README.md a été restauré à son état d'origine :

cat README.md

Ces méthodes alternatives vous offrent différentes options pour gérer l'erreur "Your local changes would be overwritten by merge" en fonction de votre situation et de vos besoins spécifiques.

Bonnes pratiques pour prévenir les conflits de fusion

Maintenant que vous savez comment résoudre l'erreur "Your local changes would be overwritten by merge", discutons de quelques bonnes pratiques pour éviter que ce problème ne se produise en premier lieu.

1. Validez fréquemment vos modifications

Effectuer des validations (commits) petites et fréquentes permet de réduire le risque de conflits de fusion :

## Make a small change
echo "// Add a comment" >> script.js

## Commit the change
git add script.js
git commit -m "Add a comment to script.js"

2. Effectuez un pull avant de pousser (push)

Effectuez toujours un pull des modifications du dépôt distant avant de pousser vos modifications :

## In a real scenario, you would do:
## git pull origin main
## Since we're working locally, let's simulate this by checking out development and back
git checkout development
git checkout main

3. Utilisez des branches de fonctionnalités (feature branches)

Créez une nouvelle branche pour chaque fonctionnalité ou correction de bogue :

## Create a new feature branch
git checkout -b feature-navbar

## Make some changes
echo "/* Navigation bar styles */" >> styles.css

## Commit the changes
git add styles.css
git commit -m "Add navigation bar styles"

Retournons à la branche principale :

git checkout main

4. Fusionnez ou rebasez régulièrement avec la branche principale

Maintenez vos branches de fonctionnalités à jour avec la branche principale :

## Switch to the feature branch
git checkout feature-navbar

## In a real scenario, you would merge or rebase with main:
## git merge main
## or
## git rebase main

## For our demonstration, let's simulate this
echo "/* More styles */" >> styles.css
git add styles.css
git commit -m "Add more styles"

## Go back to main
git checkout main

5. Utilisez Git Status fréquemment

Vérifiez toujours l'état de votre dépôt avant d'effectuer des opérations telles que la fusion ou le pull :

git status

Vous devriez voir :

On branch main
nothing to commit, working tree clean

6. Communiquez avec votre équipe

Bien que nous ne puissions pas le démontrer dans un laboratoire, la communication est essentielle pour éviter les conflits. Assurez-vous que votre équipe sait sur quels fichiers vous travaillez pour éviter les modifications simultanées sur les mêmes fichiers.

7. Utilisez des outils GUI pour les fusions complexes

Pour les conflits de fusion complexes, envisagez d'utiliser des outils GUI :

## List available GUI merge tools (in a real environment)
## git mergetool --tool-help

## In our case, let's just display what merge tools are typically available
echo "Common merge tools: meld, kdiff3, vimdiff, vscode"

En suivant ces bonnes pratiques, vous pouvez réduire considérablement l'occurrence des conflits de fusion et l'erreur "Your local changes would be overwritten by merge" dans vos flux de travail Git.

Résumé

Dans ce laboratoire, vous avez appris à gérer l'erreur "Your local changes would be overwritten by merge" dans Git. Il s'agit d'un problème courant qui se produit lorsque vous essayez de fusionner ou de tirer (pull) des modifications alors que vous avez des modifications non validées dans votre répertoire de travail.

Points clés abordés dans ce laboratoire :

  1. Vous avez créé un scénario qui a déclenché l'erreur "Your local changes would be overwritten by merge" en apportant des modifications au même fichier dans différentes branches.

  2. Vous avez appris plusieurs méthodes pour résoudre cette erreur :

    • Utilisation de git stash pour enregistrer temporairement vos modifications
    • Validation (commit) de vos modifications avant la fusion
    • Utilisation de git checkout pour annuler les modifications locales indésirables
  3. Vous avez exploré les bonnes pratiques pour prévenir les conflits de fusion :

    • Effectuer des validations (commits) fréquentes et petites
    • Tirer (pull) avant de pousser (push)
    • Utiliser des branches de fonctionnalités (feature branches)
    • Fusionner ou rebaser régulièrement avec la branche principale
    • Utiliser git status fréquemment
    • Communiquer avec votre équipe
    • Utiliser des outils GUI pour les fusions complexes

En comprenant ces concepts et techniques, vous pouvez gérer votre flux de travail Git plus efficacement et éviter les pièges courants qui mènent aux conflits de fusion.

Rappelez-vous que Git est un outil puissant pour le contrôle de version et la collaboration, mais il nécessite une gestion minutieuse des modifications pour éviter les conflits. Les compétences que vous avez acquises dans ce laboratoire vous aideront à maintenir l'intégrité de votre base de code tout en collaborant efficacement avec les autres.