Introduction
Git est un système de contrôle de version puissant qui aide les développeurs à gérer leur code et à collaborer efficacement. Cependant, il arrive parfois de rencontrer des messages d'erreur déroutants, surtout lorsque l'on débute avec Git. Une erreur courante est : "Your local changes would be overwritten by merge". Cette erreur survient lorsque Git ne peut pas fusionner les changements en toute sécurité, car cela écraserait vos modifications locales non validées (non commitées).
Dans ce laboratoire, vous apprendrez les causes de cette erreur, comment la résoudre et comment mettre en œuvre des stratégies pour éviter qu'elle ne se reproduise dans vos futurs flux de travail Git.
Comprendre le flux de travail Git
Dans cette étape, vous allez passer en revue le flux de travail Git de base et inspecter le dépôt préparé 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 des autres. Il garde une trace des modifications apportées aux fichiers au fil du temps, vous permettant de revenir à des versions précédentes si nécessaire.
Flux de travail Git de base
Un flux de travail Git typique comprend les étapes suivantes :
- Modifier des fichiers dans votre répertoire de travail
- Préparer les changements avec
git add - Valider les changements avec
git commit - Envoyer les changements vers un dépôt distant avec
git push - Récupérer les changements depuis un dépôt distant avec
git pull
Commençons
Tout d'abord, accédez à notre répertoire de projet :
cd /home/labex/project/git-merge-demo
Vérifions le statut 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 les branches disponibles :
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 ! Vous comprenez maintenant 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éer un scénario de conflit de fusion
Dans cette étape, nous allons créer un scénario menant à l'erreur "Your local changes would be overwritten by merge". Cela vous aidera à comprendre pourquoi cette erreur se produit.
Apporter des modifications sur la branche development
Tout d'abord, basculons sur la branche development et apportons 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 ce changement :
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(-)
Apporter des modifications non validées sur la branche main
Maintenant, retournons sur la branche main :
git checkout main
Vérifions que nous sommes bien sur la branche main :
git branch
Vous devriez voir :
development
* main
Maintenant, modifions le même fichier (script.js) sur la branche main, mais cette fois-ci, nous ne validerons pas les changements :
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 :
- Vous avez modifié
script.jssur la branchedevelopmentet validé les changements. - Vous avez également modifié
script.jssur la branchemainmais n'avez pas validé les changements. - Lors de la tentative de fusion, Git a détecté que vos modifications non validées seraient écrasées par l'opération de fusion.
Dans l'étape suivante, nous apprendrons comment résoudre cette erreur.
Résoudre le conflit de fusion avec Git Stash
Dans cette étape, vous allez résoudre l'erreur "Your local changes would be overwritten by merge" avec git stash. Cette commande 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 (qu'elles soient indexées ou non), les met de côté pour une utilisation ultérieure, puis restaure l'état de 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 development
Maintenant que notre répertoire de travail est propre, nous pouvons fusionner la branche development en toute sécurité :
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
Vous devriez maintenant voir :
console.log('Hello from development branch!');
Récupérer vos modifications mises de côté (stash)
Maintenant que nous avons fusionné avec succès la branche development, récupérons nos modifications mises de côté :
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
C'est normal, car Git essaie d'appliquer vos modifications mises de côté 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 avec nano :
nano script.js
Modifiez le fichier pour conserver les deux changements ou en choisir un :
// Conserver les deux changements
console.log("Hello from development branch!");
console.log("Hello from main branch!");
Enregistrez le fichier en appuyant sur Ctrl+O, puis Enter, et quittez nano en appuyant sur Ctrl+X.
Maintenant, indexons et validons le conflit résolu :
git add script.js
git commit -m "Merge development branch and resolve conflict"
Félicitations ! Vous avez résolu avec succès 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. Dans cette étape, nous explorerons d'autres approches pour gérer cette situation.
Méthode 1 : Valider vos changements avant de fusionner
L'un des moyens les plus simples d'éviter cette erreur est de valider (commiter) vos changements 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 mettre nos changements de côté, 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, basculons sur la branche development, apportons une modification au 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, retournons sur 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 changements. 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 survient 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 pour :
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 :
## Créer une modification dans README.md
echo "## Updated README" > README.md
## Vérifier le statut
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 changements, 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 original :
cat README.md
Ces méthodes alternatives vous offrent différentes options pour gérer l'erreur en fonction de votre situation et de vos besoins spécifiques.
Bonnes pratiques pour prévenir les conflits de fusion
Dans cette étape, vous allez pratiquer des habitudes qui aident à prévenir l'erreur "Your local changes would be overwritten by merge".
1. Validez fréquemment vos changements
Faire des commits petits et fréquents aide à réduire les risques de conflits de fusion :
## Faire une petite modification
echo "// Add a comment" >> script.js
## Valider le changement
git add script.js
git commit -m "Add a comment to script.js"
2. Récupérez (pull) avant d'envoyer (push)
Récupérez toujours les changements du dépôt distant avant d'envoyer les vôtres :
## Dans un scénario réel, vous feriez :
## git pull origin main
## Comme nous travaillons localement, simulons cela en basculant sur development puis en revenant
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 bug :
## Créer une nouvelle branche de fonctionnalité
git checkout -b feature-navbar
## Apporter quelques modifications
echo "/* Navigation bar styles */" >> styles.css
## Valider les changements
git add styles.css
git commit -m "Add navigation bar styles"
Retournons sur la branche main :
git checkout main
4. Fusionnez ou rebasez régulièrement avec la branche main
Gardez vos branches de fonctionnalités à jour avec la branche main :
## Basculer sur la branche de fonctionnalité
git checkout feature-navbar
## Dans un scénario réel, vous fusionneriez ou rebaseriez avec main :
## git merge main
## ou
## git rebase main
## Pour notre démonstration, simulons cela
echo "/* More styles */" >> styles.css
git add styles.css
git commit -m "Add more styles"
## Retourner sur main
git checkout main
5. Utilisez fréquemment Git Status
Vérifiez toujours le statut de votre dépôt avant d'effectuer des opérations comme une fusion ou une récupération :
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 des modifications simultanées sur les mêmes fichiers.
7. Utilisez des outils graphiques (GUI) pour les fusions complexes
Pour les conflits de fusion complexes, envisagez d'utiliser des outils graphiques :
## Lister les outils de fusion graphiques disponibles (dans un environnement réel)
## git mergetool --tool-help
## Dans notre cas, affichons simplement les outils de fusion généralement disponibles
echo "Common merge tools: meld, kdiff3, vimdiff, vscode"
En suivant ces bonnes pratiques, vous pouvez réduire considérablement l'apparition de conflits de fusion et de l'erreur "Your local changes would be overwritten by merge" dans vos flux de travail Git.
Résumé
Dans ce laboratoire, vous avez appris comment résoudre l'erreur "Your local changes would be overwritten by merge" dans Git. Il s'agit d'un problème courant qui survient lorsque vous essayez de fusionner ou de récupérer des changements alors que vous avez des modifications non validées dans votre répertoire de travail.
Points clés abordés dans ce laboratoire :
Vous avez créé un scénario déclenchant l'erreur en modifiant le même fichier dans différentes branches.
Vous avez appris plusieurs méthodes pour résoudre cette erreur :
- Utiliser
git stashpour enregistrer temporairement vos changements - Valider vos changements avant de fusionner
- Utiliser
git checkoutpour annuler des modifications locales indésirables
- Utiliser
Vous avez exploré les bonnes pratiques pour prévenir les conflits de fusion :
- Faire des commits fréquents et petits
- Récupérer (pull) avant d'envoyer (push)
- Utiliser des branches de fonctionnalités
- Fusionner ou rebaser régulièrement avec la branche main
- Utiliser
git statusfréquemment - Communiquer avec votre équipe
- Utiliser des outils graphiques 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 menant aux conflits de fusion.
N'oubliez pas que Git est un outil puissant pour le contrôle de version et la collaboration, mais qu'il nécessite une gestion rigoureuse des changements pour éviter les conflits. Les compétences acquises dans ce laboratoire vous aideront à maintenir l'intégrité de votre base de code tout en collaborant efficacement avec les autres.
