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.

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.

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?

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

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

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.

à 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.

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'
   

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>

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.

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.

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:

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

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

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.

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.

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.

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.

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

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.

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.

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