Résoudre les conflits de fusion Git?

Question

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

Answer 1

Essayez: git mergetool

Il s'ouvre sur une interface graphique qui vous guide lors de chaque conflit, et vous obtenez de choisir le mode de fusion. Parfois, il nécessite un peu de main d'édition par la suite, mais en général c'est suffisant en lui-même. Il est beaucoup mieux que de faire la chose en main certainement.

Par @JoshGlover

Eh bien, il n'est pas nécessairement une interface graphique, sauf si vous installez un. L'exécution git mergetool pour moi entraîné vimdiff 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

p4merge fonctionne très bien pour moi. Je n'ai pas essayé d'autres outils.

Answer 2

Voici une probable de cas d'utilisation, à partir du haut:

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

git fetch origin
git pull origin master

From ssh://gitosis@example.com:22/projectname
 * branch            master     -> FETCH_HEAD
Updating a030c3a..ee25213
error: Entry 'filename.c' not uptodate. Cannot merge.

Ainsi, vous obtenez à jour et essayer de nouveau, mais y a un conflit:

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

From ssh://gitosis@example.com: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.

Si vous décidez de prendre un coup d'oeil à l'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://gitosis@example.com:22/projectname
 * branch            master     -> FETCH_HEAD
Already up-to-date.

Ta-da!

Answer 3

Je trouve fusionner les outils rarement de m'aider à comprendre le conflit ou la résolution. Je suis habituellement plus de succès en regardant les marqueurs de conflit dans un éditeur de texte et à l'aide de la commande git log comme un complément.

Voici quelques conseils:

Une Astuce

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

git config merge.conflictstyle diff3

Ce produit 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 section du milieu est ce que l'ancêtre commun ressemblait. Ceci est utile parce que vous pouvez les comparer pour le haut et le bas versions pour obtenir une meilleure idée de ce qui a changé sur chaque branche, ce qui vous donne une meilleure idée de ce qu'est le but de chaque changement.

Si le conflit n'est qu'à quelques lignes, ce qui rend en général 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 de simplement appeler cette personne dans votre chambre afin qu'ils puissent voir ce que vous êtes en train de regarder.)

Si le conflit est plus long, alors je vais couper et coller chacune des trois sections de trois fichiers distincts, tels que la "mine", "commun" et "la leur".

Ensuite, je peux exécuter les commandes ci-dessous pour voir les deux diff mecs à l'origine du conflit:

diff common mine
diff common theirs

Ce n'est pas le même que l'utilisation d'un outil de fusion, depuis un outil de fusion comprendra tous les non-contradictoires diff mecs trop. Je trouve que pour être distrayant.

Astuce Deux

Quelqu'un a déjà parlé, mais la compréhension de l'intention derrière chaque diff hunk est généralement très utile pour comprendre d'où un conflit venait, et comment le gérer.

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

Cela montre tous les commits qui ont touché ce fichier entre l'ancêtre commun et les deux chefs vous êtes à la fusion. (Afin de ne pas inclure les commits qui existent déjà dans les deux branches avant de les fusionner.) Cela vous permet d'ignorer les diff mecs qui, manifestement, ne sont pas un facteur dans votre conflit actuel.

Astuce Trois

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

Si vous avez des tests automatisés, les exécuter. Si vous avez des peluches, exécutez-la. Si c'est un constructible de projet, puis de le construire avant de vous engager, etc. Dans tous les cas, vous avez besoin de faire un peu de tests pour s'assurer que vos modifications n'a rien cassé. (Heck, même une fusion sans conflits peuvent briser code du travail.)

Astuce Quatre

Planifiez à l'avance; - de communiquer avec les co-travailleurs.

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

Par exemple, si vous savez que vous et l'autre personne êtes-à la fois de travailler sur différents refactoring qui affectent le même ensemble de fichiers, vous devriez parler à l'avance de temps et d'obtenir une meilleure idée de quels types de changements à chacun de vous. Vous pourriez économiser beaucoup de temps et d'effort si vous effectuer vos changements prévus en série plutôt qu'en parallèle.

Pour les grands refactorings qui se recoupent dans une large fauchée de code, vous devriez sérieusement envisager un travail en série: tout le monde s'arrête de travailler sur la zone du code tandis qu'une personne effectue la réorganisation complète.

Si vous ne pouvez pas travailler en série (en raison de la pression du temps, peut-être), puis de communiquer sur des attendus des conflits de fusion au moins vous aide à résoudre les problèmes plus rapidement, tandis que les détails sont encore frais à l'esprit. Par exemple, si un co-travailleur est de faire un perturbateur de la série de commits au cours d'une période d'une semaine, vous pouvez choisir de fusionner/rebase sur que co-travailleurs de la branche une fois ou deux fois chaque jour pendant la semaine. 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.

Astuce Cinq

Si vous n'êtes pas sûr au sujet d'une fusion, ne le forcez pas.

La fusion peut se sentir écrasante, surtout quand il y a beaucoup de conflits de fichiers et les marqueurs de conflit avec des centaines de lignes. Souvent lors de l'estimation des projets logiciels nous n'avons pas assez de temps pour les éléments des coûts indirects, comme la manipulation d'un gnarly de fusion, de sorte qu'il se sent comme une vraie traînée de passer plusieurs heures à disséquer chaque conflit.

Dans le long terme, de la planification à l'avance et d'être conscient de ce que les autres travaillent sont les meilleurs outils pour anticiper les conflits de fusion et préparez-vous pour les résoudre correctement en moins de temps.

Answer 4

1. Identifier les fichiers qui sont en conflit (Git dois vous dire ce).

2. Ouvrir chaque fichier et d'examiner les diff; Git délimite. J'espère qu'il sera évident que la version de chaque bloc de garder. Vous devrez peut-être en discuter avec les autres développeurs qui ont commis le code.

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

4. Une fois que vous avez résolu tous les conflits, ne git rebase --continue ou la commande que Git dit de le faire lorsque vous avez terminé.

Answer 5

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