Comment résoudre les conflits de fusion dans Git

Index

Comment résoudre les conflits de fusion dans Git
1. Comment revenir à un commit dans Git ?
Questions et réponses à maîtriser

Découvrez comment résoudre efficacement les conflits de fusion dans Git, un processus essentiel pour maintenir la collaboration fluide au sein des équipes de développement.

Dans cet article, nous allons vous montrer comment résoudre les conflits de fusion dans Git. Git permet aux développeurs de créer des branches à partir de la base de code principale pour effectuer des modifications indépendantes. Ces changements peuvent ensuite être fusionnés dans le code existant. Cela permet aux équipes de travailler en parallèle sans attendre que les autres terminent leurs tâches.

Cependant, des conflits de fusion peuvent survenir si les mêmes parties de code sont modifiées dans différentes branches. Git ne peut pas toujours résoudre ces conflits par lui-même. Dans de tels cas, vous devez intervenir et les corriger manuellement.

Comment résoudre les conflits de fusion dans Git

Il existe plusieurs façons de résoudre les conflits de fusion dans Git, en fonction de votre flux de travail, des outils et de votre niveau de confort. Vous pouvez les résoudre directement dans le terminal en utilisant des commandes Git, utiliser un éditeur de texte comme VS Code, ou vous appuyer sur des outils GUI tels que GitHub Desktop, Sourcetree ou GitKraken. Comprenons comment les conflits de fusion se produisent et comment les résoudre à l'aide d'un exemple simple utilisant Git et Visual Studio Code (VS Code).

Allez sur votre compte GitHub et créez un nouveau dépôt avec un fichier README.md. Appelons ce dépôt merge-conflict-demo.

Dans le commit suivant (sur la branche principale), modifiez le fichier README.md et ajoutez un peu de texte. Validez les changements.

Note : Il n'est pas nécessaire de modifier le README.md après avoir créé le dépôt. L'objectif de cette étape (ici) est de simuler un changement sur la branche principale afin qu'un conflit puisse survenir plus tard lors de la fusion de différentes branches qui modifient également le même fichier.

Allez dans Code > Local et copiez le lien HTTPS du dépôt.

Ensuite, créez un répertoire sur votre ordinateur local. Nommez-le quelque chose comme TWC_Git_Merge_Demo. Ouvrez ce répertoire dans VS Code, lancez le terminal (trois points > Terminal > Nouveau Terminal), et clonez le dépôt GitHub en utilisant :

git clone https://github.com/sangeetaghera2710/merge-conflict-demo.git

Ensuite, naviguez dans le dépôt cloné, et créez une nouvelle branche nommée feature1 :

cd merge-conflict-demo git checkout -b feature1

Ajoutez du texte au fichier README.md, puis préparez et validez les changements :

git add . git commit -m "Ajout des changements dans feature1"

Dans cet exemple, nous avons utilisé git add . au lieu de git add README.md
git add . prépare tous les fichiers modifiés, tandis que

git add README.md ne stage que le fichier spécifié. De plus, git status est utilisé pour afficher l'état actuel du répertoire de travail et de la zone de staging.

Ensuite, revenez à la branche principale et créez une autre branche nommée feature2 :

git checkout main git checkout -b feature2

Maintenant, éditez le même fichier README.md, mais ajoutez une ligne de texte différente. Encore une fois, stagez et validez :

git add README.md git commit -m "Ajouté des modifications dans feature2"

Maintenant, revenez à la branche principale et fusionnez feature1 dedans :

git checkout main git merge feature1

Cette fusion devrait se terminer sans aucun conflit.

Ensuite, passez à la branche feature2 et fusionnez la branche principale mise à jour dedans :

git checkout feature2 git merge main

Cette fois, un conflit de fusion se produira dans le fichier README.md puisque les deux branches ont modifié la même section.

Résoudre un Conflit de Fusion

Lorsque un conflit de fusion se produit, Git ajoute des marqueurs spéciaux (<<<<<<<, =======, >>>>>>>) dans les fichiers affectés pour mettre en évidence les sections conflictuelles de chaque branche. Ces marqueurs vous aident à identifier les conflits, vous permettant de décider manuellement quelle version conserver ou comment combiner les changements avant de finaliser la fusion.

Ouvrez le fichier en conflit (README.md) dans VS Code. Vous verrez des marqueurs de conflit comme montré dans l'image ci-dessus.

VS Code vous offre quatre options pour résoudre les conflits manuellement :

Accepter le Changement Actuel : Conserver les changements de feature2.
Accepter le Changement Entrant : Conserver les changements de main (qui inclut feature1).
Accepter les Deux Changements : Conserver les deux ensembles de changements.
Comparer les Changements : Voir les différences avant de décider.

Cliquez sur Comparer les Changements. Lorsque vous cliquez sur Comparer les Changements dans VS Code pendant un conflit de fusion, cela ouvre une vue diff côte à côte du fichier en conflit. Cette vue montre les changements de votre branche actuelle (à gauche) et les changements entrants de la branche que vous fusionnez (à droite). Cela vous permet de comparer les deux versions ligne par ligne avant de choisir comment résoudre le conflit.

Vous pouvez ensuite modifier manuellement le fichier ou utiliser l'une des options comme Accepter Actuel, Accepter Entrant ou Accepter les Deux directement depuis cette vue.

Après avoir résolu le conflit, enregistrez le fichier. Ensuite, stagez et validez les changements.

git add README.md git commit -m "Résolu le conflit de fusion dans README.md"

C'est tout ! Vous avez réussi à résoudre un conflit de fusion Git en utilisant Visual Studio Code.

J'espère que vous trouvez cela utile.

Comment revenir à un commit dans Git ?

Pour revenir à un commit dans le dépôt Git, vous pouvez utiliser la commande git revert. Au lieu de supprimer le commit de l'historique de votre projet, cette commande identifie comment inverser les changements introduits par le commit et ajoute un nouveau ‘commit revert’ avec le contenu inverse résultant. Cela aide à préserver l'historique, ce qui est important pour une collaboration fiable et l'intégrité de votre projet.

Questions et réponses à maîtriser

Comment résoudre les conflits de fusion dans github ?

Pour résoudre les conflits de fusion dans GitHub, suivez ces étapes simples :

Accéder à la Pull Request :
Cliquez sur la Pull Request affichant un conflit.
Détecter les Conflits :
En bas de votre Pull Request, recherchez le bouton « Résoudre les conflits ».
Résoudre les Conflits :
Cliquez sur « Résoudre les conflits ».
Un éditeur s’ouvrira avec les parties conflictuelles du code signalées clairement.
Modifier le Code :
Revoyez les sections en conflit.
Choisissez quelle version du code garder ou combinez les changements nécessaires.
Marquer Comme Résolu :
Une fois les modifications effectuées, marquez les conflits comme résolus.
Cliquez sur « Valider la fusion » pour finaliser le processus.
Cas Complexes :
Si le bouton « Résoudre les conflits » est désactivé, le conflit est trop complexe pour être résolu directement sur GitHub. Dans ce cas, vous devrez :
Cloner le dépôt sur votre machine locale.
Utiliser des outils de fusion (comme Git en ligne de commande ou un éditeur de code) pour résoudre les conflits manuellement.
Pousser les modifications résolues sur votre branche une fois les conflits éliminés. En suivant ces étapes, vous pourrez efficacement résoudre les conflits de fusion et continuer à collaborer sur votre projet.

Comment résoudre les conflits de fusion dans les questions d'entretien Git ?

Pour résoudre les conflits de fusion lors d'une opération Git, suivez ces étapes simples :

Identifier le conflit : Lorsque vous essayez de fusionner des branches, Git vous indiquera quels fichiers sont en conflit.
Modifier les fichiers concernés : Ouvrez chaque fichier en conflit et examinez les sections marquées par Git. Vous verrez des délimitations qui montrent les modifications de chaque branche : <<<<<<< HEAD [Modifications de votre branche actuelle] ======= [Modifications de la branche fusionnée] >>>>>>> [nom de la branche fusionnée]
Sauvegarder les changements : Une fois les modifications apportées, enregistrez les fichiers.
Préparer les fichiers résolus : Utilisez la commande suivante pour marquer les fichiers comme résolus : git add [nom_fichier]
Valider la fusion : Pour terminer le processus de fusion, exécutez : git commit
Ajoutez un message de commit pour expliquer les résolutions effectuées, si nécessaire. En suivant ces étapes, vous pourrez résoudre efficacement les conflits de fusion dans Git.

Qu'est-ce qu'un conflit de fusion dans git ?

Un conflit de fusion dans Git survient lorsque vous tentez de fusionner deux branches qui contiennent des modifications contradictoires. Voici les principales caractéristiques :

Modifications concurrentes

Intervention nécessaire : Git ne peut pas décider automatiquement quelles modifications garder et nécessite votre intervention.
Résolution des conflits : Vous devez examiner les différences et choisir quelles modifications conserver, totaliser ou adapter.
Processus : Après avoir résolu les conflits, vous devez ajouter les fichiers modifiés et terminer la fusion avec un commit. En résumé, les conflits de fusion sont des situations où Git demande votre aide pour clarifier les modifications à intégrer lorsque plusieurs développements concurrentiels existent.

Comment résoudre les conflits de fusion dans Gitlab ?

Pour résoudre les conflits de fusion dans GitLab, suivez ces étapes :

Accéder aux Requêtes de Fusion :
Code
Requêtes de fusion
Recherchez la demande de fusion concernée.
Vérifier l'Aperçu :
Cliquez sur Aperçu de la requête de fusion.
Faites défiler jusqu'à la section Rapports de demandes de fusion.
Identifier les Conflits :
Recherchez le message indiquant un conflit de fusion.
Cliquez sur Résoudre les conflits pour voir la liste des fichiers affectés.
Résoudre les Conflits :
Ouvrez chaque fichier en conflit pour analyser les différences.
Modifiez le code afin de fusionner les changements en une seule version cohérente.
Assurez-vous de conserver les modifications nécessaires des deux branches.
Valider les Changements :
Une fois les conflits résolus, enregistrez les fichiers modifiés.
Confirmez les modifications et terminez le processus de fusion.
Finaliser la Demande de Fusion :
Revenez à la requête de fusion et vérifiez que tout est en ordre.
Soumettez la demande de fusion après avoir confirmé l'absence de conflits. En suivant ces étapes, vous pourrez gérer efficacement les conflits de fusion dans GitLab et assurer une intégration réussie de votre code.

Maintenant que tu as fini de lire Comment résoudre les conflits de fusion dans Git, nous t'invitons à explorer davantage la catégorie Tutoriels. Tu y trouveras d'autres articles intéressants qui élargiront tes connaissances et te tiendront informé. Ne cesse pas de lire et de découvrir plus!

Laisser un commentaire Annuler la réponse