So lösen Sie Zusammenführungskonflikte in git

Gibt es eine gute Möglichkeit, zu erklären, wie Zusammenführungskonflikte in git gelöst werden können?

4274
02 окт. Spoike Set 02 Okt. 2008-10-02 14:31 08 um 14:31 2008-10-02 14:31
@ 37 Antworten
  • 1
  • 2

Versuchen Sie: git mergetool

Es öffnet sich die grafische Benutzeroberfläche, die jeden Konflikt durchläuft, und Sie können auswählen, wie sie kombiniert werden sollen. Dies erfordert manchmal eine manuelle Nachbearbeitung, reicht aber normalerweise aus. Das ist viel besser, als alles manuell zu erledigen.

Laut dem Kommentar von @JoshGlover:

Der Befehl öffnet die GUI nicht unbedingt, wenn Sie sie nicht installieren. Das Ausführen von git mergetool für mich führte zur Verwendung von vimdiff . Sie können eines der folgenden Tools installieren, um es stattdessen zu verwenden: opendiff , opendiff , kdiff3 , tkdiff , xxdiff , tortoisemerge , gvimdiff , diffuse , ecmerge , p4merge , araxis , vimdiff , emerge .

Im Folgenden finden Sie ein Beispiel für die Verwendung von vimdiff zum vimdiff von Zusammenführungskonflikten. Über diesen Link

Schritt 1 : Führen Sie die folgenden Befehle in Ihrem Terminal aus

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

Dadurch wird vimdiff als Standardwerkzeug für die Zusammenführung festgelegt.

Schritt 2 : Führen Sie den folgenden Befehl im Terminal aus

 git mergetool 

Schritt 3 : Sie sehen eine Vimdiff-Anzeige im folgenden Format.

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

Diese 4 Typen

LOCAL ist die Datei aus dem aktuellen Zweig.

BASE - ein gemeinsamer Vorfahre, wie die Datei vor beiden Änderungen aussah

REMOTE - Eine Datei, die Sie in Ihrem Zweig zusammenführen

MERGED - das Ergebnis der Fusion, das wird im Repo gespeichert

Mit ctrl+w können Sie zwischen diesen Ansichten navigieren, mit ctrl+w und j Sie direkt in die MERGED-Ansicht.

Weitere Informationen zur Navigation von vimdiff hier und hier.

Schritt 4 Sie können MERGED wie folgt bearbeiten.

Wenn Sie Änderungen von REMOTE erhalten möchten

 :diffg RE 

Wenn Sie Änderungen von BASE erhalten möchten

 :diffg BA 

Wenn Sie Änderungen von LOCAL erhalten möchten

 :diffg LO 

Schritt 5 Speichern, beenden, sperren und löschen

:wqa speichern und :wqa vi

git commit -m "message"

git clean Löschen Sie nicht benötigte Dateien (z. B. * .orig), die vom diff-Tool erstellt wurden.

2535
02 окт. Antwort wird von Peter Burns gegeben . 2008-10-02 20:50 08 um 20:50 Uhr 2008-10-02 20:50

Hier ist ein wahrscheinlicher Präzedenzfall von oben:

Sie werden einige Änderungen vornehmen, wissen aber leider nicht:

 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. 

Sie aktualisieren und versuchen es erneut, haben jedoch einen Konflikt:

 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. 

Sie haben sich also entschieden, die Änderungen zu betrachten:

border=0
 git mergetool 

Oh, ich, oh, mein Upstream hat einige Dinge verändert, aber nur um meine Änderungen zu nutzen ... nein ... ihre Änderungen ...

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

Und dann versuchen wir es das letzte Mal.

 git pull origin master From ssh://gitosis@example.com:22/projectname * branch master -> FETCH_HEAD Already up-to-date. 

Ta-da!

1625
04 авг. Die Antwort gibt CoolAJ86 04 aug. 2010-08-04 20:04 '10 am 20:04 PM 2010-08-04 20:04

Ich finde, dass Merge-Tools mir selten helfen, Konflikte oder Lösungen zu verstehen. In der Regel schaue ich Konfliktmarker in einem Texteditor erfolgreicher an und verwende git log als Ergänzung.

Hier sind einige Tipps:

Rat eins

Das Beste, was ich gefunden habe, ist, den Diff3-Stil des Zusammenführungskonflikts zu verwenden:

git config merge.conflictstyle diff3

Es erstellt Konfliktmarkierungen wie folgt:

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

Der mittlere Teil sieht aus, wie der gemeinsame Vorfahr aussah. Dies ist nützlich, weil Sie es mit der oberen und der unteren Version vergleichen können, um besser zu verstehen, was in den einzelnen Branchen geändert wurde. Dadurch erhalten Sie eine bessere Vorstellung davon, was der Zweck jeder Änderung ist.

Wenn der Konflikt nur aus wenigen Zeilen besteht, macht dies den Konflikt in der Regel sehr offensichtlich. (Zu wissen, wie man einen Konflikt löst, ist etwas ganz anderes: Sie müssen wissen, woran andere Leute arbeiten. Wenn Sie verwirrt sind, rufen Sie einfach diese Person in Ihrem Zimmer an, damit sie sehen können, wonach Sie suchen.)

Wenn der Konflikt länger dauert, schneide und füge ich jeden der drei Abschnitte in drei separate Dateien ein, z. B. "meine", "allgemein" und "sie".

Dann kann ich die folgenden Befehle ausführen, um zwei Situationen zu sehen, die den Konflikt verursacht haben:

 diff common mine diff common theirs 

Dies ist nicht dasselbe wie bei der Verwendung des Merge-Tools, da das Merge-Tool alle nicht miteinander in Konflikt stehenden Unterschiede enthält. Ich finde es ablenkend.

Tipp zwei

Jemand hat dies bereits erwähnt, aber das Verständnis der Absicht hinter jedem Wortdiff ist in der Regel hilfreich, um zu verstehen, woher der Konflikt stammt und wie er damit umgehen soll.

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

Dies zeigt alle Commits, die diese Datei betrafen, zwischen einem gemeinsamen Vorfahren und zwei Köpfen, die Sie zusammenführen. (Die Commits, die vor dem Zusammenführen in beiden Zweigen bereits vorhanden sind, sind daher nicht enthalten.) Dies hilft, Unterschiede zu ignorieren, die in Ihrem aktuellen Konflikt eindeutig keinen Einfluss haben.

Tipp drei

Überprüfen Sie Ihre Änderungen mit automatisierten Tools.

Wenn Sie automatisierte Tests durchgeführt haben, führen Sie sie aus. Wenn Sie einen Fussel haben , führen Sie ihn aus. Wenn es sich um ein Bauprojekt handelt, muss es vor dem Abschluss des Projekts erstellt werden usw. In allen Fällen müssen Sie ein wenig testen, um sicherzustellen, dass Ihre Änderungen nicht beschädigt werden. (Heck, sogar Zusammenführen ohne Konflikte kann den Arbeitscode beschädigen.)

Tipp vier

Planen Sie voraus mit Kollegen kommunizieren

Vorausplanung und die Erkenntnis, dass andere arbeiten, kann dazu beitragen, Fusionskonflikte zu vermeiden und / oder sie früher zu lösen - so>

Wenn Sie zum Beispiel wissen, dass Sie und eine andere Person an unterschiedlichen Refactorings arbeiten, die sich auf denselben Dateisatz auswirken, sollten Sie sich vorher gut miteinander unterhalten und besser verstehen, welche Änderungen jeder von Ihnen vornimmt. Sie können viel Zeit und Mühe sparen, wenn Sie die geplanten Änderungen nacheinander und nicht parallel durchführen.

Bei großen Refactorings, die einen großen Code überqueren, sollten Sie ernsthaft erwägen, nacheinander zu arbeiten: Jeder hört auf, an diesem Codebereich zu arbeiten, und eine Person führt ein vollständiges Refactoring durch.

Wenn Sie nicht konsistent arbeiten können (möglicherweise aufgrund eines vorübergehenden Drucks), hilft das Gespräch über erwartete Zusammenführungskonflikte Ihnen zumindest dabei, Probleme früher zu lösen, so>

Tipp fünf

Wenn Sie nicht sicher sind, was die Fusion angeht, erzwingen Sie sie nicht.

Das Zusammenführen kann überwältigend sein, insbesondere wenn viele Dateien in Konflikt stehen und die Konfliktmarkierungen Hunderte von Zeilen umfassen. Bei der Bewertung von Softwareprojekten nehmen wir oft nicht genügend Zeit für Aufschläge ein, wie etwa die Verarbeitung einer verrückten Fusion. Daher ist es ein echter Widerstand, mehrere Konflikte zu analysieren.

>

696
29 сент. Die Antwort wird von Mark E. Haase 29 Sep gegeben. 2011-09-29 00:08 11 um 0:08 2011-09-29 00:08
  • Bestimmen Sie, welche Dateien in Konflikt sind (Git sollte Ihnen dies mitteilen).

  • Öffnen Sie jede Datei und erfahren Sie die Unterschiede. Git grenzt sie ab. Ich hoffe, es ist offensichtlich, welche Version jedes Blocks beibehalten werden soll. Möglicherweise müssen Sie dies mit anderen Entwicklern besprechen, die den Code abgeschlossen haben.

  • Sobald Sie den Konflikt in der git add the_file Datei gelöst haben, git add the_file die Datei git add the_file .

  • Sobald Sie alle Konflikte gelöst haben, führen Sie git rebase --continue oder einen beliebigen Befehl aus, den Git zum Abschluss gebracht hat.

326
02 окт. die antwort wird gegeben davetron5000 02 oct. 2008-10-02 15:41 08 um 15:41 Uhr 2008-10-02 15:41

Überprüfen Sie die Antworten in der Frage zum Abbrechen des Git-Abbruchs , insbesondere die Antwort von Charles Bailey , in der dargestellt wird, wie verschiedene Versionen einer Problemdatei angezeigt werden

100
03 окт. Antwort von Pat Notz am 3. Oktober 2008-10-03 18:15 08 um 18:15 Uhr 2008-10-03 18:15

Das Zusammenführen von Konflikten tritt auf, wenn gleichzeitig Änderungen an einer Datei vorgenommen werden. So lösen Sie es

git CLI

Hier sind die einfachen Schritte, die Sie ausführen müssen, wenn Sie sich in einem Konflikt befinden:

  • Beachten Sie die Liste der in Konflikt stehenden Dateien: git status (im Abschnitt Unmerged paths ).
  • Lösen Sie Konflikte für jede Datei separat mit einem der folgenden Ansätze:

    • Verwenden Sie die GUI, um Konflikte zu lösen: git mergetool (der einfachste Weg).

    • Um eine entfernte / andere Version zu akzeptieren, verwenden Sie: git checkout --theirs path/file . Dadurch werden alle lokalen Änderungen, die Sie an dieser Datei vorgenommen haben, abgelehnt.

    • Um die lokale / unsere Version zu akzeptieren, verwenden Sie: git checkout --ours path/file

      Sie müssen jedoch vorsichtig sein, da die gelöschten Änderungen aus irgendeinem Grund entfernt wurden.

      Verwandte: Was bedeutet "unser" und "sie" in git genau?

    • Bearbeiten Sie die in Konflikt stehenden Dateien manuell, und <<<<< >>>>> den Codeblock zwischen <<<<< / >>>>> <<<<< >>>>> dann die darüber oder darunter ===== Version ===== . Siehe: Darstellung von Konflikten .

    • Pfad- und Dateinamenkonflikte können mit git add / git rm gelöst werden.

  • Überprüfen Sie abschließend die Dateien, die zur Übernahme bereit sind, mit: git status .

    Wenn sich immer noch Dateien unter Unmerged paths und Sie den Konflikt manuell gelöst haben, Unmerged paths Sie Git mit, dass Sie ihn gelöst haben: git add path/file .

  • Wenn alle Konflikte erfolgreich gelöst wurden, kopieren Sie die Änderungen: git commit -a und klicken Sie wie gewohnt auf den gelöschten.

Siehe auch: Beheben eines Zusammenführungskonflikts über die Befehlszeile in GitHub

DiffMerge

Ich habe erfolgreich DiffMerge verwendet , mit dem Dateien in Windows, Mac OS und Linux / Unix visuell verglichen und zusammengeführt werden können.

Es zeigt Änderungen zwischen drei Dateien grafisch an und ermöglicht das automatische Zusammenführen (wenn dies sicher ist) und die vollständige Kontrolle über die Bearbeitung der resultierenden Datei.

2019

05 авг. Die Antwort ist Kenorb 05 August gegeben . 2015-08-05 17:29 '15 um 17:29 2015-08-05 17:29

Wenn Sie häufige Small Commits durchführen, sehen Sie sich zunächst die Commit-Kommentare mit git log --merge . Dann zeigt git diff Konflikte.

Bei Konflikten mit mehreren Zeilen ist es einfacher zu erkennen, was im externen GUI-Tool passiert. Ich mag opendiff - Git unterstützt auch vimdiff, gvimdiff, kdiff3, tkdiff, meld, xxdiff, ist out of the box, und Sie können andere installieren: git config merge.tool "your.tool" installiert Ihr ausgewähltes Werkzeug und git mergetool nach erfolglosen git mergetool Merge zeigt Unterschiede im Kontext.

Jedes Mal, wenn Sie eine Datei bearbeiten, um einen Konflikt zu beheben, aktualisiert git add filename den Index, und Ihr Diff zeigt ihn nicht mehr an. Wenn alle Konflikte verarbeitet wurden und ihre Dateien git add -ed wurden, schließt git commit die Zusammenführung ab.

75
02 окт. Die Antwort ist Paul 02. Okt. gegeben. 2008-10-02 19:11 08 um 07:11 Uhr 2008-10-02 19:11

Sehen Sie unter Darstellung von Konflikten oder in Git, der Dokumentation zum git merge , nach, was Konfliktmarker sind.

Darüber hinaus wird im Abschnitt " So lösen Sie Konflikte " erläutert, wie Sie Konflikte lösen können:

Nachdem Sie den Konflikt angezeigt haben, können Sie zwei Dinge tun:

  • Entscheide dich, nicht zu verschmelzen. Die einzigen Reinigungsmittel, die Sie benötigen, sind eine Reset-Indexdatei zum Fixieren des HEAD für die inverse Transformation 2. und zum Löschen der in 2. und 3 vorgenommenen Änderungen des Working Village. git merge --abort kann hierfür verwendet werden.

  • Konflikte lösen Git markiert Konflikte im Arbeitsbaum. Bearbeiten Sie die Dateien im Formular und git add sie zum Index hinzu. Verwenden Sie git commit , um einen Deal zu besiegeln.

Sie können mit mehreren Tools in Konflikt stehen:

  • Verwenden Sie Mergetool. git mergetool , um ein grafisches mergetool auszuführen, das eine Zusammenführung durchführt.

  • Schau dir die Unterschiede an. git diff zeigt einen dreiseitigen Diff an, der Änderungen gegenüber den MERGE_HEAD HEAD und MERGE_HEAD .

  • Sehen Sie sich die Unterschiede zwischen den einzelnen Niederlassungen an. git log --merge -p <path> zeigt zuerst diff für die HEAD Version und dann die MERGE_HEAD Version.

  • Schauen Sie sich die Originale an. git show :1:filename zeigt den gemeinsamen Vorfahren, git show :2:filename zeigt die Version von HEAD und git show :3:filename zeigt die Version von MERGE_HEAD .

Informationen zu den Marken des Zusammenführungskonflikts und zu deren Lösung finden Sie im Abschnitt " Pro Git Main Merge Conflicts".

43
14 июля '13 в 21:34 2013-07-14 21:34 Die Antwort wird von user456814 14. Juli 13 um 21:34 2013-07-14 21:34 gegeben

Für Emacs: Benutzer, die halbmanuelle Zusammenführungskonflikte lösen möchten:

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

Zeigt alle Dateien an, für die eine Konfliktlösung erforderlich ist.

Öffnen Sie jede dieser Dateien einzeln oder alle gleichzeitig:

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

Wenn Sie einen Puffer besuchen, der in Emacs bearbeitet werden muss, geben Sie Folgendes ein

 ALT+x vc-resolve-conflicts 

Dadurch werden die drei Puffer geöffnet (meine, sie und der Ausgabepuffer). Navigieren Sie durch Drücken von "n" (nächster Bereich) und "p" (Vorhersagebereich). Drücken Sie "a" und "b", um meinen bzw. Ihren Bereich in den Ausgabepuffer zu kopieren. Und / oder den Ausgabepuffer direkt bearbeiten.

Wenn Sie fertig sind, drücken Sie "q". Emacs fragt Sie, ob Sie diesen Puffer speichern möchten: Ja. Wenn der Puffer abgeschlossen ist, markieren Sie ihn beim Start vom Caster als gelöst:

 git add FILENAME 

Nachdem Sie mit allen Arten von Puffern gearbeitet haben

 git commit 

um die Verschmelzung abzuschließen.

36
23 февр. die antwort ist gegeben eci 23. februar 2013-02-23 02:04 '13 um 2:04 2013-02-23 02:04

Ich möchte entweder meine Version oder ihre Version vollständig, oder ich möchte die einzelnen Änderungen sehen und für jede einzelne eine Entscheidung treffen.

Akzeptiere meine oder ihre Version vollständig :

Akzeptiere meine Version (lokal, unsere):

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

Akzeptiere ihre Version (löschte sie):

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

Wenn Sie alle in Konflikt stehenden Dateien ausführen möchten, führen Sie Folgendes aus:

 git merge --strategy-option ours 

oder

 git merge --strategy-option theirs 

Überprüfen Sie alle Änderungen und akzeptieren Sie sie einzeln.

  1. git mergetool
  2. Überprüfen Sie die Änderungen und akzeptieren Sie jede Version.
  3. git add <filename>
  4. git commit -m "merged bla bla"

Standardmäßig arbeitet mergetool in der Befehlszeile . Die Verwendung der Befehlszeile mergetool sollte ein separates Problem darstellen.

Sie können dazu auch ein visuelles Tool installieren, z. B. meld und ausführen

 git mergetool -t meld 

Die lokale (unsere), "grundlegende" oder "vereinheitlichte" Version (das aktuelle Ergebnis der Zusammenführung) und die Remote (s) werden geöffnet. Speichern Sie die zusammengeführte Version, wenn Sie fertig sind, führen Sie git mergetool -t meld bis Sie "Keine Dateien zusammenführen" erhalten. git mergetool -t meld Sie dann mit Schritt 3 und 4 fort.

28
29 сент. Die Antwort wird von Noidea 29 Sep gegeben . 2016-09-29 16:02 '16 am 16:02 2016-09-29 16:02

Führen Sie die folgenden Schritte aus, um Zusammenführungskonflikte in git zu beheben:

  1. Überprüfen Sie Git Status : Git Status

  2. Holen Sie sich das Patch-Set: git fetch (überprüfen Sie den korrekten Patch von Ihrem Git- Commit)

  3. Extrahiere den lokalen Zweig (in meinem Beispiel temp1): git checkout -b temp1

  4. Extrahieren Sie den letzten Inhalt von master: git pull --rebase origin master

  5. Führen Sie mergetool aus, überprüfen Sie die Konflikte und beheben Sie sie ... und überprüfen Sie die Änderungen im entfernten Zweig mit Ihrem aktuellen Zweig: git mergetool

  6. Überprüfen Sie den Status erneut: Git-Status

  7. Löschen Sie nicht benötigte Dateien, die lokal mit mergetool erstellt wurden. In der Regel erstellt mergetool eine zusätzliche Datei mit der Erweiterung * .orig. Bitte löschen Sie diese Datei, da es sich nur um ein Duplikat handelt, korrigieren Sie die Änderungen lokal und fügen Sie die korrekte Version Ihrer Dateien hinzu. git add #your_changed_correct_files

  8. Überprüfen Sie den Status erneut: Git-Status

  9. Übernehmen Sie die Änderungen für denselben Bezeichner (dies vermeidet einen neuen Satz von Korrekturen): git commit --amend

  10. Push zum Master-Zweig: git Push (zu Ihrem Git-Repository)

28
16 апр. Die Antwort ist gegeben Chhabilal 16 April. 2015-04-16 10:02 '15 am 10:02 16.04.2015 10:02

Wenn Sie genau wissen, dass Änderungen in einem der Repositorys nicht wichtig sind und Sie alle Änderungen zugunsten des anderen zulassen möchten, verwenden Sie Folgendes:

 git checkout . --ours 

Änderungen zu Gunsten Ihres Repository zulassen, oder

 git checkout . --theirs 

Änderungen zu Gunsten eines anderen oder des Hauptdepuments zulassen.

Oder Sie müssen das GUI-Merge-Tool verwenden, um die Dateien schrittweise p4merge , beispielsweise das p4merge Merge- p4merge , oder einen beliebigen Namen zu schreiben, den Sie bereits festgelegt haben.

 git mergetool -t p4merge 

Nachdem Sie die Datei erstellt haben, müssen Sie sie speichern und schließen, um die nächste Datei zu öffnen.

27
26 янв. Beantwortet von Mohamed Selim am 26. Januar 2016-01-26 20:42 '16 um 20:42 Uhr 2016-01-26 20:42

Sie können Zusammenführungskonflikte auf verschiedene Arten beheben, da andere ausführlich beschrieben wurden.

Ich denke, der eigentliche Schlüssel ist zu wissen, wie Änderungen mit lokalen und Remote-Repositories ablaufen. Der Schlüssel dazu ist das Verständnis der Nachverfolgungszweige. Ich habe festgestellt, dass ich den Tracking-Zweig als den „fehlenden Teil in der Mitte“ zwischen meinem lokalen, aktuellen Dateiverzeichnis und dem als Ursprung definierten Remote-Verzeichnis sehe.

Ich habe mich an zwei Dinge gewöhnt, um das zu vermeiden.

Anstelle von:

 git add . git commit -m"some msg" 

Was hat zwei Nachteile -

a) Alle neuen / geänderten Dateien werden hinzugefügt und können einige unerwünschte Änderungen enthalten.
b) Sie können die Liste der Dateien nicht zuerst anzeigen.

Also stattdessen:

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

Auf diese Weise diskutieren Sie bewusster, welche Dateien hinzugefügt werden, und Sie können auch durch die Liste blättern und mit dem Editor für die Nachricht ein wenig nachdenken. Ich finde, dass es auch meine Commit-Nachrichten verbessert, wenn ich den Vollbild-Editor anstelle der Option -m .

[Update - Mit der Zeit wechselte ich weiter zu:

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

]

Auch (und besser für Ihre Situation) versuche ich zu vermeiden:

 git pull 

oder

 git pull origin master. 

da pull das Zusammenführen impliziert und wenn Sie lokale Änderungen haben, die Sie nicht zusammenführen möchten, können Sie den zusammengeführten Code problemlos abschließen und / oder Konflikte für Code zusammenführen, der nicht zusammengeführt werden soll.

Вместо этого я пытаюсь сделать

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

Вы также можете найти это полезным:

git branch, fork, fetch, merge, rebase und clone, was sind die unterschiede?

25
ответ дан Michael Durrant 19 апр. '13 в 4:08 2013-04-19 04:08

Bonus:

Говоря о pull/fetch/merge в приведенных выше ответах, я хотел бы поделиться интересным и продуктивным трюком,

git pull --rebase

Эта вышеприведенная команда является самой полезной командой в моей жизни git, которая сэкономила много времени.

Прежде чем нажимать вновь сделанное изменение на удаленный сервер, попробуйте git pull --rebase скорее git pull и ручной merge , и он автоматически синхронизирует последние удаленные изменения сервера (с помощью слияния + слияние) и поместит локальную последнюю фиксацию в вершина в журнале git. Не нужно беспокоиться о ручном вытягивании/слиянии.

В случае конфликта просто используйте

 git mergetool git add conflict_file git rebase --continue 

Найти информацию по адресу: http://gitolite.com/git-pull--rebase

25
ответ дан Sazzad Hissain Khan 25 дек. '15 в 18:24 2015-12-25 18:24

Ответ CoolAJ86 подводит итог всему. Если у вас есть изменения в обеих ветвях в одном и том же фрагменте кода, вам придется выполнить ручное слияние. Откройте файл в конфликте в любом текстовом редакторе, и вы увидите следующую структуру.

 (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) 

Выберите один из вариантов или комбинацию обоих способов, которым вы хотите новый код, при удалении равных знаков и угловых скобок.

 git commit -a -m "commit message" git push origin master 
22
ответ дан iankit 25 янв. '14 в 19:17 2014-01-25 19:17

Есть 3 шага:

  1. Найти какие файлы вызывают конфликты по команде

     git status 
  2. Проверьте файлы, в которых вы найдете конфликты, помеченные как

     <<<<<<<<head blablabla 
  3. Измените его так, как вы хотите, затем подтвердите с помощью команд

     git add solved_conflicts_files git commit -m 'merge msg' 
18
ответ дан Qijun Liu 23 июня '17 в 17:38 2017-06-23 17:38
 git log --merge -p [[--] path] 

Кажется, что я всегда не работаю для меня и обычно заканчивает отображение каждой фиксации, которая была разной между двумя ветвями, это происходит даже при использовании -- для разделения пути от команды.

Что я делаю, чтобы обойти эту проблему, открыть две строки команд и за один проход

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

а в другом

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

Заменив $MERGED_IN_BRANCH ветвью, я объединил и [path] с конфликтующим файлом. Эта команда будет записывать все коммиты в форме патча между ( .. ) двумя коммитами. Если вы оставите одну сторону пустой, как в командах выше, git будет автоматически использовать HEAD (ветвь, в которую вы сливаетесь в этом случае).

Это позволит вам увидеть, какие коммиты вошли в файл в двух ветвях после их расхождения. Обычно это упрощает разрешение конфликтов.

15
ответ дан Brian Di Palma 11 дек. '14 в 18:19 2014-12-11 18:19

С 12 декабря 2016 года вы можете объединять ветки и разрешать конфликты на github.com

Таким образом, если вы не хотите использовать командную строку или любые сторонние инструменты, предлагаемые здесь из более старых @, перейдите к собственному инструменту GitHub.

Это сообщение в блоге подробно объясняется, но основы заключаются в том, что при объединении двух ветвей через пользовательский интерфейс вы увидите" разрешить конфликты, который приведет вас к редактору, позволяющему справиться с этими конфликтами слияния.

2019

ответ дан maxwell 09 янв. '17 в 22:45 2017-01-09 22:45

Используя patience

Я удивлен, что никто не говорил об урегулировании конфликта, используя patience с рекурсивной стратегией слияния. Для большого конфликта слияния использование patience дало хорошие результаты для меня. Идея состоит в том, что он будет пытаться сопоставить блоки, а не отдельные линии.

Например, если вы изменяете отступ вашей программы, стратегия слияния Git по умолчанию иногда соответствует одиночным скобкам { которые принадлежат разным функциям. Этого избегают с patience :

 git merge -s recursive -X patience other-branch 

Aus der Dokumentation:

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

Сравнение с общим предком

Если у вас есть конфликт слияния и вы хотите увидеть, что другие имели в виду при изменении своей ветки, иногда проще сравнить их ветвь напрямую с общим предком (вместо нашей ветки). Для этого вы можете использовать merge-base :

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

Обычно вы хотите видеть изменения только для определенного файла:

 git diff $(git merge-base <our-branch> <their-branch>) <their-branch> <file> 
14
ответ дан Conchylicultor 30 нояб. '16 в 22:51 2016-11-30 22:51

Я всегда выполняю следующие шаги, чтобы избежать конфликтов.

  • git мастер проверки (придите к мастер-ветке)
  • git pull (обновите свой мастер, чтобы получить последний код)
  • git checkout -b mybranch (закажите новую ветку и начните работу над этой ветвью, чтобы ваш мастер всегда оставался верхом ствола.)
  • git add. AND git commit AND git push (на вашей локальной ветке после ваших изменений)
  • git мастер проверки (вернитесь к своему хозяину.)

Теперь вы можете делать то же самое и поддерживать столько локальных веток, сколько хотите, и работать одновременно, просто делая приказ git к вашей ветке, когда это необходимо.

12
ответ дан Chetan 12 февр. '15 в 7:25 2015-02-12 07:25

Если вы хотите объединить ветвь (тест) с мастером, вы можете выполнить следующие шаги:

Шаг 1: Перейти в ветку

 git checkout test 

Шаг 2: git pull --rebase origin master

Шаг 3: Если есть конфликты, перейдите к этим файлам, чтобы изменить его.

Шаг 4: Добавьте эти изменения

 git add #your_changes_files 

Шаг 5: git rebase --continue

Шаг 6: если конфликт все еще существует, вернитесь к шагу 3 снова. Если конфликта нет, сделайте следующее: git push origin +test

Шаг 7: И тогда между тестом и мастером нет конфликта. Вы можете использовать слияние напрямую.

11
ответ дан Haimei 18 авг. '14 в 22:42 2014-08-18 22:42

Конфликты слияния могут возникать в разных ситуациях:

  • При запуске "git fetch", а затем "git merge"
  • При запуске "git fetch", а затем "git rebase"
  • При запуске "git pull" (что фактически соответствует одному из вышеупомянутых условий)
  • При запуске "git stash pop"
  • Когда вы применяете git-патчи (коммиты, которые экспортируются в файлы для передачи, например, по электронной почте)

Вам нужно установить инструмент слияния, совместимый с Git, для разрешения конфликтов. Я лично использую KDiff3, и я нашел это хорошим и удобным. Вы можете скачать его версию для Windows здесь:

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

Кстати, если вы устанавливаете Git Extensions, в его мастере настройки есть опция для установки Kdiff3.

Затем настройте git config для использования Kdiff в качестве 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 

(Не забудьте заменить путь на фактический путь к исполняемому файлу Kdiff.)

Затем каждый раз, когда вы сталкиваетесь с конфликтом слияния, вам просто нужно выполнить эту команду:

 $git mergetool 

Затем он открывает Kdiff3 и сначала пытается автоматически разрешить конфликты слияния. Большинство конфликтов будут разрешены спонтанно, а остальные нужно исправить вручную.

Вот как выглядит Kdiff3:

2019

ответ дан akazemis 18 июня '16 в 8:29 2016-06-18 08:29

Этот ответ заключается в том, чтобы добавить альтернативу тем пользователям VIM, как я, которые предпочитают делать все в редакторе.


Tl; DR

2019

ответ дан Vicente Adolfo Bolea Sánchez 16 окт. '17 в 9:01 2017-10-16 09:01

git holen
git checkout ваша ветка
git мастер переадресации

На этом шаге вы попытаетесь исправить конфликт, используя предпочитаемый вами вариант IDE

Вы можете перейти по этой ссылке, чтобы проверить ho, чтобы исправить конфликт в файле
https://help.github.com/articles/resolving-a-merge-conflict-using-the-command-line/

git добавить
git rebase - продолжить git commit --amend
git push origin HEAD: refs/drafts/master (нажмите, как черновики)

Теперь все прекрасно, и вы найдете свою фиксацию в геррите

Я надеюсь, что это поможет каждому в решении этой проблемы.

3
ответ дан Baini.Marouane 05 июля '17 в 16:25 2017-07-05 16:25

Попробуйте Visual Studio Code для редактирования, если вы еще этого не сделали. После попытки слияния (и попадания в конфликты слияния).VS код автоматически обнаруживает конфликты слияния.

Это может помочь вам очень хорошо, показывая, какие изменения были внесены в оригинал, и если вы принимаете incoming или

current change (имеется в виду оригинальное перед слиянием) '?.

Это помогло мне, и это может работать на вас тоже!

PS: он будет работать, только если вы настроили git с помощью своего кода и кода Visual Studio.

2
ответ дан Kailash Bhalaki 16 марта '18 в 9:26 2018-03-16 09:26

Gitlense For VS Code

Вы можете попробовать Gitlense для VS Code, ключевые характеристики которого:

3. Легко разрешать конфликты.

Мне уже нравится эта функция:

2019

ответ дан Ilyas karim 05 янв. '19 в 21:33 2019-01-05 21:33

Я следую нижеописанному процессу.

Процесс устранения конфликта слияния:

  • Сначала вытащите последнюю из ветки назначения, к которой вы хотите объединить git pull origin develop

  • По мере того, как вы получаете последнее сообщение от адресата, теперь разрешите конфликт вручную в среде IDE, удалив лишние символы.

  • Сделайте git add , чтобы добавить эти отредактированные файлы в очередь git, чтобы она могла быть commit и push той же ветки, над которой вы работаете.

  • Как git add , выполните a git commit , чтобы зафиксировать изменения.

  • Теперь переместите изменения в рабочую ветвь на git push origin HEAD

Это он, и вы увидите, что он разрешен в вашем запросе на pull, если вы используете Bitbucket или GitHub.

1
ответ дан Aniruddha Das 14 окт. '17 в 0:49 2017-10-14 00:49

Если вы используете intelliJ как IDE Попробуйте объединить родителя с веткой на

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

Он отобразит все конфликты вроде этого

A_MBPro: test anu $ git слияние источника/автоматическое слияние src/test/java/com/.../TestClass.java CONFLICT (содержание): Объединить конфликт в SRC/тест/Java/COM/.../TestClass.java

Теперь обратите внимание, что файл TestClass.java отображается красным цветом в intelliJ Также статус git будет показывать

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

Откройте файл в intelliJ, он будет иметь разделы с

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

где HEAD - это изменения в локальной ветке, а origin/- изменения в удаленной ветке. Здесь держите нужные вещи и удаляйте ненужные вещи. После этого должны выполняться обычные шаги. Das

  git add TestClass.java git commit -m "commit message" git push 
1
ответ дан AJC 11 июля '17 в 19:23 2017-07-11 19:23

Для тех, кто использует Visual Studio (2015 в моем случае)

  • Закройте свой проект в VS. Особенно в больших проектах VS, как правило, увлекается слиянием с использованием пользовательского интерфейса.

  • Сделайте слияние в командной строке.

    git checkout target_branch

    git merge source_branch

  • Затем откройте проект в VS и перейдите в Team Explorer → Branch. Теперь есть сообщение, в котором говорится, что Merge находится в ожидании, и конфликтующие файлы перечислены прямо под сообщением.

  • Нажмите конфликтующий файл, и у вас будет возможность объединить, сравнить, взять источник, принять цель. Инструмент слияния в VS очень прост в использовании.

1
ответ дан Mike 10 июля '17 в 23:29 2017-07-10 23:29

Если вы не хотите использовать какой-либо сторонний или графический инструмент, выполните шаги, указанные в этих документах, чтобы разрешить конфликты слияния.

https://githowto.com/resolving_conflicts

https://confluence.atlassian.com/bitbucket/resolve-merge-conflicts-704414003.html

0
ответ дан Always_Beginner 02 дек. '17 в 20:53 2017-12-02 20:53
  • 1
  • 2

Другие вопросы по меткам или Задайте вопрос