Comment résoudre les conflits de fusion dans Git

Est-il une bonne façon d'expliquer comment résoudre les conflits de fusion Git?

4200
demandé sur Peter Mortensen 0000-00-00 00:00:00
la source

30 ответов

, Essayez: git mergetool

il ouvre une interface graphique qui vous guide à travers chaque conflit, et vous pouvez choisir comment fusionner. Parfois, il faut un peu de travail manuel, mais en général, ça suffit tout seul. Il est beaucoup mieux que de faire la chose en main certainement.

selon le commentaire de @JoshGlover:

la commande n'ouvre pas nécessairement une interface graphique à moins d'en installer une. git mergetool pour moi résultat: vimdiff est utilisé. Vous pouvez installer l'un des outils suivants pour l'utiliser à la place: meld , opendiff , kdiff3 , tkdiff , xxdiff , tortoisemerge , gvimdiff , diffuse , ecmerge , p4merge , araxis , vimdiff , emerge .

ci-dessous est la procédure type pour utiliser vimdiff pour résoudre les conflits de fusion. Basé sur ce lien

Étape 1 : exécuter les commandes suivantes dans votre terminal

git config merge.tool vimdiff
git config merge.conflictstyle diff3
git config mergetool.prompt false

cela définira vimdiff comme outil de fusion par défaut.

Étape 2 : exécuter la commande suivante dans le terminal

git mergetool

Étape 3 : vous verrez un écran vimdiff dans le format suivant

  +----------------------+
  |       |      |       |
  |LOCAL  |BASE  |REMOTE |
  |       |      |       |
  +----------------------+
  |      MERGED          |
  |                      |
  +----------------------+

ces 4 vues sont

LOCAL – c'est le fichier de la branche courante

base-ancêtre commun, à quoi ressemblait file avant les deux changements

"1519290920 à DISTANCE" fichier de fusion dans votre branche

résultat de la fusion-fusion, c'est ce qui est enregistré dans le repo

vous pouvez naviguer parmi ces vues en utilisant ctrl+w . Vous pouvez accéder directement à la vue fusionnée en utilisant ctrl+w suivi de j .

plus d'informations sur la navigation vimdiff ici et ici

Étape 4 . Vous pouvez éditer la vue fusionnée de la manière suivante

si vous voulez obtenir des changements à distance

:diffg RE  

si vous voulez obtenir des changements à partir de la BASE

:diffg BA  

si vous souhaitez obtenir des changements à partir de

:diffg LO 

l'Étape 5 . Enregistrer, Quitter, s'Engager et à Nettoyer

:wqa enregistrer et quitter vi

git commit -m "message"

git clean supprimer les fichiers supplémentaires (par exemple *.orig) créé par diff tool.

2472
répondu Peter Burns 2018-03-23 13:52:49
la source

voici un cas d'utilisation probable, du haut:

Vous allez tirer quelques changements, mais oups, vous n'êtes pas à jour:

git fetch origin
git pull origin master

From ssh://[email protected]:22/projectname
 * branch            master     -> FETCH_HEAD
Updating a030c3a..ee25213
error: Entry 'filename.c' not uptodate. Cannot merge.

alors vous vous mettez à jour et vous réessayez, mais vous avez un conflit:

git add filename.c
git commit -m "made some wild and crazy changes"
git pull origin master

From ssh://[email protected]:22/projectname
 * branch            master     -> FETCH_HEAD
Auto-merging filename.c
CONFLICT (content): Merge conflict in filename.c
Automatic merge failed; fix conflicts and then commit the result.

donc vous décidez de jeter un oeil aux changements:

git mergetool

Oh moi, oh mon dieu, en amont changé certaines choses, mais juste d'utiliser mes modifications...non...leurs modifications...

git checkout --ours filename.c
git checkout --theirs filename.c
git add filename.c
git commit -m "using theirs"

Et puis nous essayons une dernière fois

git pull origin master

From ssh://[email protected]:22/projectname
 * branch            master     -> FETCH_HEAD
Already up-to-date.

Ta-da!

1617
répondu CoolAJ86 2014-04-17 03:13:42
la source

je trouve que les outils de fusion m'aident rarement à comprendre le conflit ou la résolution. Je suis généralement plus efficace en regardant les marqueurs de conflit dans un éditeur de texte et en utilisant git log comme un supplément.

Voici quelques conseils:

Pointe Un

la meilleure chose que j'ai trouvée est d'utiliser le style de conflit de fusion" diff3":

git config merge.conflictstyle diff3

cela produit des marqueurs de conflit comme ceci:

<<<<<<<
Changes made on the branch that is being merged into. In most cases,
this is the branch that I have currently checked out (i.e. HEAD).
|||||||
The common ancestor version.
=======
Changes made on the branch that is being merged in. This is often a 
feature/topic branch.
>>>>>>>

la partie centrale est ce à quoi ressemblait l'ancêtre commun. C'est utile parce que vous pouvez le comparer aux versions supérieure et inférieure pour avoir une meilleure idée de ce qui a été changé sur chaque branche, ce qui vous donne une meilleure idée de l'objectif de chaque changement.

si le conflit n'est que de quelques lignes, cela rend généralement le conflit très évident. (Sachant comment résoudre un conflit est très différente, vous devez être conscient de ce que d'autres personnes travaillent sur. Si vous êtes confus, il est probablement préférable d'appeler cette personne dans votre chambre afin qu'ils puissent voir ce que vous regardez.)

si le conflit est plus long, alors je vais couper et coller chacune des trois sections en trois fichiers distincts, tels que" mine"," common "et"leur".

alors je peux exécuter les commandes suivantes pour voir les deux hunks diff qui ont causé le conflit:

diff common mine
diff common theirs

Ce n'est pas le même chose que d'utiliser un outil de fusion, car un outil de fusion inclura tous les points de différence non-conflictuels aussi. Je trouve que pour être distrayant.

Conseil "Les Deux 151990920"

Quelqu'un l'a déjà mentionné, mais comprendre l'intention derrière chaque morceau de diff est généralement très utile pour comprendre d'où vient un conflit et comment le gérer.

git log --merge -p <name of file>

cette affiche toutes les commits qui ont touché ce fichier entre les l'ancêtre et les deux têtes que vous fusionnez. (Donc il n'inclut pas les propagations qui existent déjà dans les deux branches avant la fusion. Cela vous aide à ignorer les différences qui ne sont clairement pas un facteur dans votre conflit actuel.

Conseil Des Trois

Vérifiez vos modifications avec des outils automatisés.

si vous avez des tests automatisés, lancez-les. Si vous avez un peluches , exécutez-la. Si c'est un projet constructible, alors construisez-le avant vous vous engagez, etc. Dans tous les cas, vous devez faire un peu de tests pour vous assurer que vos changements n'ont rien cassé. (Diable, même une fusion sans conflits peut briser le code de travail.)

Pointe Quatre

Planifiez à l'avance; communiquez avec vos collègues.

planifier à l'avance et être conscient de ce sur quoi les autres travaillent peut aider à prévenir les conflits de fusion et/ou aider à les résoudre plus tôt-alors que les détails sont encore frais à l'esprit.

par exemple, si vous savez que vous et une autre personne travaillez sur un remaniement différent qui affectera le même ensemble de fichiers, vous devriez vous parler à l'avance et avoir un meilleur sens des types de changements que chacun d'entre vous est en train de faire. Vous économiserez beaucoup de temps et d'efforts si vous effectuez vos changements prévus en série plutôt qu'en parallèle.

pour les remaniements majeurs qui coupent à travers une large bande de code, vous devriez fortement envisagez de travailler en série: tout le monde arrête de travailler sur cette partie du code pendant qu'une personne effectue le remaniement complet.

si vous ne pouvez pas travailler en série (à cause de la pression du temps, peut-être), alors communiquer sur les conflits de fusion prévus au moins vous aide à résoudre les problèmes plus tôt alors que les détails sont encore frais à l'esprit. Par exemple, si un collègue de travail crée une série perturbatrice de propagations au cours d'une période d'une semaine, vous pouvez choisir de fusionner ou de reformuler au cours de cette semaine, les collègues se réunissent une ou deux fois par jour. De cette façon, si vous trouvez de fusion/rebase conflits, vous pouvez les résoudre plus rapidement que si vous attendez quelques semaines pour fusionner tout ensemble dans une grosse masse.

Conseil Des Cinq

si vous n'êtes pas sûr d'une fusion, ne la forcez pas.

la fusion peut sembler accablante, surtout lorsqu'il y a beaucoup de dossiers conflictuels et que les marqueurs de conflit couvrent des centaines de lignes. Souvent lors de l'estimation de projets logiciels, nous n'incluons pas assez de temps pour les éléments de frais généraux comme la gestion d'une fusion gnarly, de sorte qu'il se sent comme une véritable traînée de passer plusieurs heures à disséquer chaque conflit.

à long terme, planifier à l'avance et être conscient de ce sur quoi les autres travaillent sont les meilleurs outils pour anticiper les conflits de fusion et se préparer à les résoudre correctement en moins de temps.

690
répondu Mark E. Haase 2014-07-23 21:32:54
la source
  1. identifiez les fichiers qui sont en conflit (Git devrait vous le dire).

  2. ouvrir chaque fichier et examiner les diffs; Git les délimite. Avec un peu de chance, il sera évident quelle version de chaque bloc garder. Vous aurez peut-être besoin d'en discuter avec d'autres développeurs qui ont commis le code.

  3. une fois que vous avez résolu le conflit dans un dossier git add the_file .

  4. une fois que vous avez résolu tous conflits, faire git rebase --continue ou n'importe quelle commande Git a dit de faire quand vous avez terminé.

322
répondu davetron5000 2014-08-07 21:48:46
la source

découvrez les réponses dans le Débordement de la Pile question Abandon d'une fusion dans Git , en particulier Charles Bailey réponse , qui montre comment afficher les différentes versions d'un fichier avec des problèmes, par exemple,

# Common base version of the file.
git show :1:some_file.cpp

# 'Ours' version of the file.
git show :2:some_file.cpp

# 'Theirs' version of the file.
git show :3:some_file.cpp
98
répondu Pat Notz 2017-05-23 14:47:34
la source

conflits de fusion se produit lorsque des modifications sont apportées à un fichier en même temps. Voici comment le résoudre.

git CLI

Voici des étapes simples que faire lorsque vous entrez en conflit:

  1. notez la liste des fichiers en conflit avec: git status (sous Unmerged paths section).
  2. résolvez les conflits séparément pour chaque fichier par l'un des moyens suivants: approches:

    • utilisez GUI pour résoudre les conflits: git mergetool (la voie la plus facile).

    • Pour accepter à distance/autre version: git checkout --theirs path/file . Cela rejettera tout changement local que vous avez fait pour ce fichier.

    • pour accepter local/ notre version, utiliser: git checkout --ours path/file

      cependant, vous devez être prudent, que les changements à distance que les conflits ont été fait pour une raison.

      Related: Quel est le sens précis de "l'ours" et "leurs" git?

    • Éditez les fichiers en conflit manuellement et recherchez le bloc de code entre <<<<< / >>>>> puis choisissez la version au-dessus ou au-dessous de ===== . Voir: Comment les conflits sont présentés .

    • les conflits de chemin et de nom de fichier peuvent être résolus par git add / git rm .

  3. enfin, passez en revue les fichiers prêts à être envoyés en utilisant git status .

    si vous avez encore des fichiers sous Unmerged paths , et que vous avez résolu le conflit manuellement, faites savoir à Git que vous l'avez résolu en: git add path/file .

  4. Si tous les les conflits ont été résolus avec succès, commettez les changements par: git commit -a et poussez à distance comme d'habitude.

Voir aussi: résoudre un conflit de fusion à partir de la ligne de commande at GitHub

DiffMerge

j'ai utilisé avec succès DiffMerge qui peut comparer visuellement et fusionner des fichiers sur Windows, macOS et Linux/Unix.

It graphiquement peut afficher les changements entre 3 fichiers et il permet la fusion automatique (quand il est sûr de le faire) et le contrôle complet sur l'édition du fichier résultant.

DiffMerge

Image source: DiffMerge (screenshot Linux)

il suffit de le télécharger et exécuter dans repo comme:

git mergetool -t diffmerge .

macOS

sur macOS vous pouvez installer via:

brew install caskroom/cask/brew-cask
brew cask install diffmerge

et probablement (si non fourni) vous avez besoin de l'emballage simple supplémentaire suivant placé dans votre chemin (par exemple /usr/bin ):

#!/bin/sh
DIFFMERGE_PATH=/Applications/DiffMerge.app
DIFFMERGE_EXE=${DIFFMERGE_PATH}/Contents/MacOS/DiffMerge
exec ${DIFFMERGE_EXE} --nosplash "[email protected]"

, Alors vous pouvez utiliser les raccourcis clavier suivants:

  • - Alt - / Vers Le Bas pour passer aux changements précédents/suivants.
  • - Alt - Gauche / Droit pour accepter le changement à partir de la gauche ou de droite

alternativement vous pouvez utiliser opendiff (partie des outils Xcode) qui vous permet de fusionner deux fichiers ou répertoires ensemble pour créer un troisième fichier ou répertoire.

89
répondu kenorb 2017-05-23 13:31:39
la source

si vous faites de fréquentes petites commissions, alors commencez par regarder les commentaires de commit avec git log --merge . Puis git diff vous montrera les conflits.

pour les conflits qui impliquent plus de quelques lignes, il est plus facile de voir ce qui se passe dans un outil D'interface graphique externe. J'aime opendiff -- Git soutient aussi vimdiff, gvimdiff, kdiff3, tkdiff, meld, xxdiff, sortent de la boîte et vous pouvez installer d'autres: git config merge.tool "your.tool" définira votre outil choisi et puis git mergetool après une fusion ratée vous montrera les diffs en contexte.

chaque fois que vous éditez un fichier pour résoudre un conflit, git add filename mettra à jour l'index et votre diff ne le montrera plus. Lorsque tous les conflits sont traités et que leurs fichiers ont été git add -ed, git commit complétera votre Fusion.

74
répondu Paul 2014-07-23 21:43:21
la source

Voir Comment les Conflits Sont Présentés ou, dans Git, le git merge de la documentation pour comprendre ce conflit de fusion sont les marqueurs.

aussi, la section comment résoudre les conflits explique comment résoudre les conflits:

Après avoir vu un conflit, vous pouvez faire deux choses:

  • décider de ne pas fusionner. La seule les nettoyages dont vous avez besoin sont de réinitialiser le fichier index vers le HEAD commit to reverse 2. et pour nettoyer les changements apportés par 2. et 3.; git merge --abort peut être utilisé pour cela.

  • résoudre les conflits. Git marquera les conflits dans l'arbre de travail. Modifiez les fichiers en forme et git add les à l'index. Utiliser git commit pour sceller l'affaire.

vous pouvez travailler à travers le conflit avec un certain nombre d'outils:

  • utilisez un mergetool. git mergetool pour lancer un mergetool graphique qui vous fonctionnera à travers la fusion.

  • Regardez les diff. git diff montrera une différence à trois sens, mettant en évidence les changements des versions HEAD et MERGE_HEAD .

  • regardez les diffs de chaque branche. git log --merge -p <path> affichera diffs d'abord pour la version HEAD et ensuite la version MERGE_HEAD .

  • Regardez les originaux. git show :1:filename montre l'ancêtre commun, git show :2:filename montre la version HEAD , et git show :3:filename montre la version MERGE_HEAD .

vous pouvez également lire à propos de fusionner les marqueurs de conflit et comment les résoudre dans le Pro Git section du livre Basic Merge Conflicts .

43
répondu Peter Mortensen 2014-07-23 21:22:15
la source

pour Emacs utilisateurs qui veulent résoudre semi-manuellement les conflits de fusion:

git diff --name-status --diff-filter=U

affiche tous les fichiers qui nécessitent une résolution de conflit.

ouvrir chacun de ces fichiers un par un, ou tous à la fois par:

emacs $(git diff --name-only --diff-filter=U)

lors de la visite d'un tampon nécessitant des modifications dans Emacs, tapez

ALT+x vc-resolve-conflicts

cela ouvrira trois tampons (mine, leur, et le tampon de sortie). Naviguez en appuyant sur ' n '(région suivante),' p ' (région de prévision). Appuyez sur " a " et " b " pour copier mine ou leur région dans le tampon de sortie, respectivement. Et / ou éditer le tampon de sortie directement.

une fois terminé: appuyez sur "q". Emacs vous demande si vous voulez sauvegarder cette mémoire tampon: oui. Après avoir terminé un tampon marquez-le comme résolu en courant à partir du teriminal:

git add FILENAME

lorsqu'il est terminé avec tous les tampons du type

git commit

à terminer la fusion.

36
répondu eci 2014-07-23 21:24:52
la source

s'il vous plaît suivre les étapes suivantes pour corriger les conflits de fusion dans Git:

  1. Vérifier le statut Git: git status

  2. Obtenir le nouveau jeu de patches: git fetch 151980920 "(vérifiez le patch de droite de votre git commit)

  3. Caisse une succursale locale (temp1 dans mon exemple ici): git checkout-b temp1

  4. : git pull --rebase origine de maître

  5. Démarrer le mergetool et vérifiez les conflits et à les résoudre...et vérifiez les changements dans la branche distante avec votre branche actuelle: git mergetool

  6. vérifiez à nouveau l'état: git status

  7. Supprimer les fichiers inutiles créés localement par mergetool, généralement mergetool crée des fichiers *.orig extension. Veuillez supprimer ce fichier car il ne s'agit que de dupliquer et corriger les modifications localement et ajouter la version correcte de vos fichiers. git ajouter # your_changed_correct_files

  8. vérifiez à nouveau l'état: git status

  9. valider les modifications apportées à la même commettre id (ce qui évite un nouveau jeu de patch): git commit -- amend

  10. Pousser à la branche master: git push (à votre dépôt Git)

28
répondu Chhabilal 2018-06-19 06:25:07
la source

tout Simplement, si vous savez bien que les changements dans l'un des dépôts n'est pas important, et que vous voulez résoudre tous les changements en faveur de l'autre, utilisez:

git checkout . --ours

pour résoudre les changements en faveur de votre dépôt , ou

git checkout . --theirs

pour résoudre les changements en faveur du autre ou du dépôt principal .

sinon vous devrez utiliser un outil de fusion GUI pour step à travers les fichiers un par un, dites que l'outil de fusion est p4merge , ou écrivez le nom de quelqu'un que vous avez déjà installé

git mergetool -t p4merge

et après avoir terminé un fichier, vous devrez vous enregistrer et fermer, donc, le prochain s'ouvrira.

27
répondu Mohamed Selim 2018-06-19 06:26:09
la source

soit je veux ma version ou leur version complète, soit je veux passer en revue les changements individuels et décider pour chacun d'eux.

Accept Fully my or their version :

Accepter ma version (local, la nôtre):

git checkout --ours -- <filename>
git add <filename>              # Marks conflict as resolved
git commit -m "merged bla bla"  # An "empty" commit

accepter leur version (à distance, la leur):

git checkout --theirs -- <filename>
git add <filename>
git commit -m "merged bla bla"

Si vous voulez faire pour tous les conflits de fichiers run:

git merge --strategy-option ours

ou

git merge --strategy-option theirs

examiner toutes les modifications et les accepter individuellement

  1. git mergetool
  2. examiner les modifications et accepter l'une ou l'autre version pour chacune d'elles.
  3. git add <filename>
  4. git commit -m "merged bla bla"

par Défaut mergetool œuvres ligne de commande . Comment utiliser une ligne de commande mergetool devrait être une question distincte.

vous pouvez également installer outil visuel pour cela, par exemple meld et exécuter

git mergetool -t meld

il ouvrira la version locale (la nôtre), la version" de base "ou" fusionnée " (le résultat actuel de la fusion) et la version distante (la leur). Sauvegardez la version fusionnée lorsque vous avez terminé, exécutez à nouveau git mergetool -t meld jusqu'à ce que vous obteniez "aucun fichier n'a besoin de fusionner", puis allez aux étapes 3. et 4.

26
répondu Noidea 2018-06-19 06:29:48
la source

vous pouvez corriger les conflits de fusion de plusieurs façons comme les autres ont détaillé.

je pense que la vraie clé est de savoir comment les changements s'opèrent avec les dépôts locaux et distants. La clé de cette compréhension est de comprendre le suivi des directions générales. J'ai trouvé que je pense à la branche de suivi comme la "pièce manquante au milieu" entre moi mon local, répertoire de fichiers réels et la télécommande définie comme origine.

j'ai personnellement pris l'habitude de 2 choses aider à éviter cela.

au lieu de:

git add .
git commit -m"some msg"

qui a deux inconvénients -

a) tous les fichiers nouveaux/modifiés sont ajoutés et peuvent inclure des modifications non désirées.

b) vous n'avez pas à consulter la liste des dossiers en premier.

donc à la place je fais:

git add file,file2,file3...
git commit # Then type the files in the editor and save-quit.

de cette façon, vous êtes plus délibérés sur les fichiers qui sont ajoutés et vous pouvez également passer en revue la liste et penser un peu plus tout en utilisant l'éditeur pour le message. Je trouve que cela améliore aussi mes messages de propagation lorsque j'utilise un éditeur plein écran plutôt que l'option -m .

[mise à Jour - comme le temps a passé, j'ai basculé plus à:

git status # Make sure I know whats going on
git add .
git commit # Then use the editor

]

aussi (et plus pertinent à votre situation), j'essaie d'éviter:

git pull

ou

git pull origin master.

parce que pull implique une fusion et si vous avez des modifications locales que vous ne vouliez pas fusionner, vous pouvez facilement vous retrouver avec du code fusionné et/ou fusionner des conflits pour du code qui n'aurait pas dû être fusionné.

au lieu de cela j'essaie de faire

git checkout master
git fetch   
git rebase --hard origin/master # or whatever branch I want.

vous pouvez également trouver cette utile:

git branch, fourche, d'extraction, de fusion, rebase et clone, quelles sont les différences?

25
répondu Michael Durrant 2017-05-23 15:18:27
la source

Bonus:

en parlant de pull / fetch / merge dans les réponses ci-dessus, je voudrais partager un tour intéressant et productif,

git pull --rebase

cette commande ci-dessus est la commande la plus utile dans ma vie git qui a sauvé beaucoup de temps.

avant de pousser votre changement nouvellement engagé sur le serveur distant, essayez git pull --rebase plutôt git pull et manuel merge et il synchronisera automatiquement les dernières modifications du serveur distant (avec une fusion fetch+) et placera votre dernière propagation locale au sommet du git log. Pas besoin de vous soucier de la traction/fusion manuelle.

En cas de conflit, il suffit d'utiliser

git mergetool
git add conflict_file
git rebase --continue

pour plus de détails: http://gitolite.com/git-pull--rebase

25
répondu Sazzad Hissain Khan 2015-12-31 06:30:19
la source

la réponse de CoolAJ86 résume à peu près tout. Dans le cas où vous avez des changements dans les deux branches dans le même morceau de code, vous devrez faire une fusion manuelle. Ouvrez le fichier en conflit dans n'importe quel éditeur de texte et vous devriez voir la structure suivante.

(Code not in Conflict)
>>>>>>>>>>>
(first alternative for conflict starts here)
Multiple code lines here
===========
(second alternative for conflict starts here)
Multiple code lines here too    
<<<<<<<<<<<
(Code not in conflict here)

choisissez l'une des alternatives ou une combinaison des deux d'une manière que vous voulez que le nouveau code soit, tout en supprimant les signes égaux et les crochets d'angle.

git commit -a -m "commit message"
git push origin master
22
répondu iankit 2014-07-23 21:17:38
la source
git log --merge -p [[--] path]

ne semble pas toujours fonctionner pour moi et finit généralement par afficher chaque commit qui était différent entre les deux branches, cela se produit même en utilisant -- pour séparer le chemin de la commande.

ce que je fais pour contourner ce problème, c'est ouvrir deux lignes de commande et en une seule fois

git log ..$MERGED_IN_BRANCH --pretty=full -p [path]

et dans l'autre

git log $MERGED_IN_BRANCH.. --pretty=full -p [path]

remplaçant $MERGED_IN_BRANCH par la branche que j'ai fusionnée dans et [path] avec le dossier qui est contradictoire. Cette commande enregistrera toutes les propagations, sous forme de patch, entre ( .. ) deux propagations. Si vous laissez un côté vide comme dans les commandes ci-dessus git utilisera automatiquement HEAD (la branche que vous fusionnent dans ce cas).

cela vous permettra de voir ce que les commits sont entrés dans le fichier dans les deux branches après avoir divergé. Il est généralement beaucoup plus facile de résoudre les conflits.

15
répondu Brian Di Palma 2016-01-05 06:45:43
la source

à partir du 12 décembre 2016, vous pouvez fusionner les branches et résoudre les conflits sur github.com

ainsi, si vous ne voulez pas utiliser la ligne de commande ou tous les outils tiers qui sont offerts ici à partir de réponses plus anciennes , allez avec l'outil natif de GitHub.

cet article de blog explique en détail, mais les bases sont que lors de la "fusion" deux branches via L'UI, vous verrez maintenant un 'resolve conflicts' option qui vous mènera à un éditeur vous permettant de gérer ces conflits de fusion.

enter image description here

15
répondu maxwell 2017-01-09 22:57:14
la source

il y a 3 étapes:

  1. trouver quels fichiers provoquent des conflits par commande

    git status
    
  2. vérifiez les fichiers, dans lesquels vous trouverez les conflits marqués comme

    <<<<<<<<head
    blablabla
    
  3. changez - le comme vous le voulez, puis commit avec des commandes

    git add solved_conflicts_files
    git commit -m 'merge msg'
    
15
répondu Qijun Liu 2018-07-06 00:03:45
la source

utilisant patience

je suis surpris que personne d'autre n'ait parlé de résoudre un conflit en utilisant patience avec la stratégie de fusion récursive. Pour un grand conflit de fusion, l'utilisation de patience a fourni de bons résultats pour moi. L'idée est qu'il va essayer de faire correspondre des blocs plutôt que des lignes individuelles.

si vous changez l'indentation de votre programme par exemple, la stratégie de fusion par défaut de Git correspond parfois à des braces simples { qui appartient à des fonctions différentes. Ceci est évité avec patience :

git merge -s recursive -X patience other-branch

de la documentation:

With this option, merge-recursive spends a little extra time to avoid 
mismerges that sometimes occur due to unimportant matching lines 
(e.g., braces from distinct functions). Use this when the branches to 
be merged have diverged wildly.

comparaison avec l'ancêtre commun

si vous avez un conflit de fusion et que vous voulez voir ce que les autres avaient en tête lors de la modification de leur branche, il est parfois plus facile de comparer directement leur branche avec l'ancêtre commun (au lieu de notre branche). Pour cela vous pouvez utiliser merge-base :

git diff $(git merge-base <our-branch> <their-branch>) <their-branch>

habituellement, vous voulez voir seulement les changements pour un dossier particulier:

git diff $(git merge-base <our-branch> <their-branch>) <their-branch> <file>
14
répondu Conchylicultor 2018-06-19 06:31:39
la source

je suis toujours les étapes ci-dessous pour éviter les conflits.

  • git checkout master (Venir à la branche master)
  • git pull (mise à Jour de votre maître pour obtenir la dernière version du code)
  • git checkout -b mybranch (Checkout une nouvelle branche et de commencer à travailler sur cette branche de sorte que votre maître reste toujours en haut du tronc.)
  • git add . Et git commit et git push (sur votre branche locale après vos changements)
  • git checkout master (revenez à votre master.)

Maintenant, vous pouvez faire la même chose et maintenir autant de branches locales que vous voulez et travailler simultanément mon juste faire un checkout git à votre branche quand jamais nécessaire.

12
répondu Chetan 2015-02-12 07:25:58
la source

si vous voulez fusionner de branche (test) à maître, vous pouvez suivre ces étapes:

Étape 1: Aller à la branche

git checkout test

Étape 2: git pull --rebase origin master

Étape 3: s'il y a des conflits, allez dans ces fichiers pour les modifier.

Étape 4: ajouter ces modifications

git add #your_changes_files

Étape 5: git rebase --continue

Étape 6: s'il y a encore un conflit, retournez à étape 3. S'il n'y a pas de conflit, faites ce qui suit: git push origin +test

Étape 7: et puis il n'y a pas de conflit entre test et master. Vous pouvez utiliser de fusion directement.

11
répondu Haimei 2018-06-19 06:23:34
la source

des conflits de Fusion peuvent survenir dans différentes situations:

  • lors de l'exécution de "git fetch" puis" git merge "
  • quand on exécute "git fetch" et ensuite" git rebase
  • Lorsqu'on exécute "git pull" (qui est en fait égale à l'une des conditions susmentionnées)
  • Lors de l'exécution de "git stash pop"
  • lorsque vous appliquez des patches git (commits qui sont exportés vers des fichiers à être transféré, par exemple, par courriel)

, Vous devez installer un outil de fusion qui est compatible avec Git pour résoudre les conflits. J'utilise personnellement KDiff3, et je l'ai trouvé agréable et pratique. Vous pouvez télécharger sa version de Windows ici:

https://sourceforge.net/projects/kdiff3/files /

BTW si vous installez des Extensions Git, il y a une option dans son assistant d'installation pour installer Kdiff3.

puis configurer Git configs pour utiliser Kdiff comme son mergetool:

$ git config --global --add merge.tool kdiff3
$ git config --global --add mergetool.kdiff3.path "C:/Program Files/KDiff3/kdiff3.exe"
$ git config --global --add mergetool.kdiff3.trustExitCode false

$ git config --global --add diff.guitool kdiff3
$ git config --global --add difftool.kdiff3.path "C:/Program Files/KDiff3/kdiff3.exe"
$ git config --global --add difftool.kdiff3.trustExitCode false

(N'oubliez pas de remplacer le chemin par le chemin réel du fichier exe de Kdiff.)

Ensuite chaque fois que vous rencontrez un conflit de fusion vous avez juste besoin d'exécuter cette commande:

$git mergetool

puis il ouvre le Kdiff3, et tente d'abord de résoudre les conflits de fusion automatiquement. La plupart des conflits seraient résolus spontanément et vous devez réparer le reste manuellement.

voici à quoi ressemble Kdiff3:

Enter image description here

ensuite, une fois que vous avez terminé, enregistrez le fichier et il va au fichier suivant avec le conflit et vous faites la même chose à nouveau jusqu'à ce que tous les conflits sont résolus.

pour vérifier si tout est fusionné avec succès, il suffit d'exécuter la commande mergetool à nouveau, vous devriez obtenir ce résultat:

$git mergetool
No files need merging
10
répondu akazemis 2018-06-19 06:28:18
la source

cette réponse est d'ajouter une alternative pour les utilisateurs de VIM comme moi qui préfère tout faire dans l'éditeur.


TL; DR

enter image description here


Tpope est venu avec ce grand plugin pour VIM appelé fugitif . Une fois installé, vous pouvez lancer :Gstatus pour vérifier les fichiers qui ont des conflits et :Gdiff pour ouvrir git dans une fusion à 3 voies.

une fois dans la fusion à trois voies, fugitif vous permettra d'obtenir les changements de l'une des branches que vous fusionnez de la façon suivante:

  • :diffget //2 , obtenir des changements de l'original ( tête ) branche:
  • :diffget //3 , prise en compte des modifications de la fusion de la branche:

une fois que vous avez terminé fusion du fichier, tapez :Gwrite dans le tampon fusionné. Vimcasts a publié une grande vidéo expliquant en détail cette étape.

7
répondu Vicente Adolfo Bolea Sánchez 2018-05-10 14:45:24
la source

git fetch

git checkout de branche

git rebase maître

dans cette étape, vous essaierez de corriger le conflit en utilisant votre IDE préféré

vous pouvez suivre ce lien pour vérifier ho pour corriger le conflit dans le fichier

https://help.github.com/articles/resolving-a-merge-conflict-using-the-command-line/

git ajouter

git rebase --continue

git commit -- amend

git push origine tête: ref/drafts / master (push like a drafts)
151930920

maintenant tout va bien et vous trouverez votre commit à gerrit

j'espère que cela aidera chacun à ce sujet.

3
répondu Baini.Marouane 2017-07-05 16:25:30
la source

essayez le code de studio visuel pour l'édition si vous n'êtes pas déjà. Ce qu'il fait est après que vous essayez de fusionner(et atterrissez dans les conflits de fusion).Le code VS détecte automatiquement les conflits de fusion.

Il peut vous aider très bien en montrant quelles sont les modifications apportées à l'original et que vous l'acceptez incoming ou

current change (signifiant original avant Fusion)"?.

Il a contribué pour moi, et il peut travailler pour vous aussi !

PS: cela ne fonctionnera que si vous avez configuré git avec votre code et Visual Studio Code.

2
répondu Kailash Bhalaki 2018-03-16 09:26:08
la source

pour ceux qui utilisent Visual Studio (2015 dans mon cas)

  1. fermez votre projet dans VS. Surtout dans les grands projets VS a tendance à paniquer en fusionnant en utilisant L'UI.

  2. Faire de la fusion à l'invite de commande.

    git checkout target_branch

    git merge source_branch

  3. puis ouvrir le projet dans VS et allez à Team Explorer - > branche. Maintenant, il y a un message qui dit que la fusion est en attente et que les fichiers contradictoires sont listés juste en dessous du message.

  4. cliquez sur le fichier en conflit et vous aurez l'option de fusionner, comparer, prendre Source, prendre cible. L'outil de fusion dans VS est très facile à utiliser.

1
répondu Mike 2017-07-10 23:29:53
la source

si vous utilisez intelliJ comme IDE Essayez de fusionner parent à votre branche par

git checkout <localbranch>
git merge origin/<remotebranch>

il montrera tous les conflits comme celui-ci

A_MBPro: test anu$ git merge origin/Auto-merging src/test/java/com/.../ TestClass.conflit java (contenu): fusionner les conflits src/test/java/com/.../ TestClass.java

maintenant notez que le fichier TestClass.java s'affiche en rouge dans intelliJ Aussi statut git montrera

Unmerged paths:
(use "git add <file>..." to mark resolution)
both modified:   src/test/java/com/.../TestClass.java

ouvrir le fichier dans intelliJ, il aura des sections avec

  <<<<<<< HEAD
    public void testMethod() {
    }
    =======
    public void testMethod() { ...
    }
    >>>>>>> origin/<remotebranch>

où HEAD est un changement de la branche locale et origin/ is un changement de la branche distante. Ici, gardez ce dont vous avez besoin et retirez ce dont vous n'avez pas besoin.Après cela, les étapes normales devraient faire. C'est-à-dire

   git add TestClass.java
   git commit -m "commit message"
   git push
1
répondu AJC 2017-08-07 18:09:13
la source

je suis le processus ci-dessous.

Le processus pour résoudre conflit de fusion:

  1. tout d'abord, tirer la dernière de la branche de destination à laquelle vous voulez fusionner git pull origin develop

  2. comme vous obtenez la dernière de la destination, maintenant résoudre le conflit manuellement dans IDE en supprimant ces caractères supplémentaires.

  3. Faire un git add pour ajouter ces fichiers modifiés à la file d'attente git afin qu'il puisse être commit et push à la même branche que vous travaillez.

  4. Comme git add est fait, faites un git commit pour valider les modifications.

  5. poussez maintenant les changements à votre branche de travail par git push origin HEAD

C'est ici et vous le verrez résolu dans votre demande de pull si vous êtes utiliser Bitbucket ou GitHub.

1
répondu Aniruddha Das 2017-11-23 12:06:54
la source

une façon plus sûre de résoudre les conflits est d'utiliser git-mediate (les solutions courantes suggérées ici sont tout à fait sujettes à erreur imho).

Voir ce post pour une introduction rapide sur la façon de l'utiliser.

0
répondu yairchu 2016-12-29 19:46:35
la source
git checkout branch1

git fetch origin

git rebase -p origin/mainbranch

s'il y a des conflits de fusion, corrigez-les. Ensuite, continuez le processus de rebase en exécutant: git rebase –-continue

après la fixation vous pouvez commit et pousser votre branche locale à la branche distante

git push origin branch1
0
répondu Vinayak Shedgeri 2018-01-15 12:15:45
la source