tool - git tutorial merge conflict




So lösen Sie Zusammenführungskonflikte in Git (20)

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


git holen
git checkout dein Zweig
git rebase master

In diesem Schritt versuchen Sie, den Konflikt mithilfe Ihrer bevorzugten IDE zu beheben

Über diesen Link können Sie prüfen, wie Sie den Konflikt in der Datei https://help.github.com/articles/resolving-a-merge-conflict-using-the-command-line/ beheben
https://help.github.com/articles/resolving-a-merge-conflict-using-the-command-line/

git add
git rebase - weiter
git begehen --amend
git push herkunft HEAD: refs / drafts / master (Push wie ein Entwurf)

Jetzt ist alles in Ordnung und Sie werden Ihr Engagement in Gerrit finden

Ich hoffe, dass dies jedem in dieser Angelegenheit helfen wird.


Bonus:

Wenn ich in den obigen Antworten von Pull / Fetch / Merge spreche, möchte ich einen interessanten und produktiven Trick teilen:

git pull --rebase

Dieser Befehl ist der nützlichste Befehl in meinem Git-Leben, der viel Zeit gespart hat.

Bevor Sie die neu festgeschriebene Änderung auf den Remote-Server übertragen, versuchen Sie git pull --rebase stattdessen git pull und manuell merge und es werden automatisch die letzten Remote-Server-Änderungen (mit Abruf + Zusammenführen) synchronisiert, und Ihr lokales aktuelles Commit wird in git angezeigt Log. Sie müssen sich keine Gedanken über manuelles Ziehen / Zusammenführen machen.

Im Konfliktfall einfach verwenden

git mergetool
git add conflict_file
git rebase --continue

Details finden Sie unter: http://gitolite.com/git-pull--rebase


  1. Identifizieren Sie, welche Dateien in Konflikt sind (Git sollte Ihnen dies mitteilen).

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

  3. Sobald Sie den Konflikt in einer Datei gelöst haben, git add the_file Datei git add the_file .

  4. Wenn Sie alle Konflikte gelöst haben, führen Sie git rebase --continue oder den Befehl aus, den Git nach Abschluss des git rebase --continue soll.


Bitte befolgen Sie die folgenden Schritte, um Zusammenführungskonflikte in Git zu beheben:

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

  2. Holen Sie sich das Patchset: git fetch (checken Sie den richtigen Patch aus Ihrem Git-Commit)

  3. Kasse eine lokale Filiale (in meinem Beispiel temp1): git checkout -b temp1

  4. Ziehen Sie den neuesten Inhalt von master: git pull --rebase origin master

  5. Starten Sie das Mergetool und prüfen Sie die Konflikte und beheben Sie diese ... 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 die unerwünschten Dateien, die lokal von mergetool erstellt wurden. In der Regel erstellt mergetool eine zusätzliche Datei mit der Erweiterung * .orig. Bitte löschen Sie diese Datei, da dies nur das Duplikat ist, und korrigieren Sie Änderungen lokal und fügen Sie die richtige Version Ihrer Dateien hinzu. git add #your_changed_correct_files

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

  9. Übernehmen Sie die Änderungen an derselben Commit-ID (dies vermeidet einen neuen separaten Patch-Satz): git commit --amend

  10. Push an den Master-Zweig: git Push (an Ihr Git-Repository)


Es gibt 3 Schritte:

  1. Finden Sie heraus, welche Dateien Konflikte verursachen

    git status
    
  2. Überprüfen Sie die Dateien, in denen Sie die Konflikte wie markiert finden würden

    <<<<<<<<head
    blablabla
    
  3. Ändern Sie es so, wie Sie es möchten, und bestätigen Sie die Befehle

    git add solved_conflicts_files
    git commit -m 'merge msg'
    

Für Emacs Benutzer, die Zusammenführungskonflikte halb manuell 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 nacheinander oder alle auf einmal durch:

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 drei Puffer geöffnet (meine, ihre und der Ausgabepuffer). Navigieren Sie durch Drücken von 'n' (nächster Bereich) und 'p' (vorheriger Bereich). Drücken Sie 'a' und 'b', um meine oder ihre Region 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. Nach dem Beenden eines Puffers kennzeichnen Sie es als gelöst, indem Sie vor dem Verbrecher laufen:

git add FILENAME

Wenn Sie mit allen Puffern fertig sind

git commit

die Verschmelzung beenden.


Ich finde, Merge-Tools helfen mir selten, den Konflikt oder die Lösung zu verstehen. Ich bin normalerweise erfolgreicher, wenn ich die Konfliktmarker in einem Texteditor anschaue und git log als Ergänzung nehme.

Hier sind ein paar Tipps:

Tipp eins

Das Beste, was ich gefunden habe, ist den Merge-Konfliktstil "diff3" zu verwenden:

git config merge.conflictstyle diff3

Dies erzeugt Konfliktmarker 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 (i.e. HEAD).
|||||||
The common ancestor version.
=======
Changes made on the branch that is being merged in. This is often a 
feature/topic branch.
>>>>>>>

Im Mittelteil sah der gemeinsame Vorfahr aus. Dies ist nützlich, da Sie es mit der oberen und der unteren Version vergleichen können, um ein besseres Verständnis dafür zu erhalten, was in jedem Zweig geändert wurde. Dadurch erhalten Sie eine bessere Vorstellung davon, was der Zweck der jeweiligen Änderung war.

Wenn der Konflikt nur aus wenigen Zeilen besteht, wird der Konflikt im Allgemeinen sehr offensichtlich. (Zu wissen, wie ein Konflikt gelöst werden kann, ist etwas ganz anderes. Sie müssen wissen, woran andere Personen arbeiten. Wenn Sie verwirrt sind, ist es am besten, wenn Sie diese Person in Ihrem Zimmer anrufen, damit sie sehen können, was Sie suchen beim.)

Wenn der Konflikt länger dauert, werde ich jeden der drei Abschnitte ausschneiden und in drei separate Dateien einfügen, z. B. "meine", "gemeinsame" und "ihre".

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

diff common mine
diff common theirs

Dies ist nicht dasselbe wie bei der Verwendung eines Merge-Tools, da ein Merge-Tool auch alle nicht konfliktbehafteten Unterschiede enthält. Ich finde das ablenkend.

Tipp zwei

Jemand hat dies bereits erwähnt, aber das Verständnis der Absicht hinter jedem Unterschied ist in der Regel sehr hilfreich, um zu verstehen, woher ein Konflikt kam und wie er damit umgehen sollte.

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

Hier werden alle Commits angezeigt, die diese Datei zwischen dem gemeinsamen Vorfahren und den beiden Köpfen, die Sie zusammenführen, berührt haben. (Daher sind keine Commits enthalten, die vor dem Zusammenführen in beiden Zweigen bereits vorhanden sind.) Dies hilft Ihnen, Unterschiede zu ignorieren, die eindeutig keinen Einfluss auf Ihren aktuellen Konflikt haben.

Tipp drei

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

Wenn Sie automatisierte Tests durchgeführt haben, führen Sie diese aus. Wenn Sie einen lint , führen Sie das aus. Wenn es sich um ein erstellbares Projekt handelt, erstellen Sie es vor dem Festschreiben usw. In allen Fällen müssen Sie einige Tests durchführen, um sicherzustellen, dass Ihre Änderungen nichts beschädigen. (Heck, sogar eine Zusammenführung ohne Konflikte kann den Arbeitscode beschädigen.)

Tipp vier

Vorausplanen; mit Kollegen kommunizieren.

Vorausplanen und wissen, woran andere arbeiten, kann dazu beitragen, Zusammenführungskonflikte zu vermeiden und / oder sie früher zu lösen - während die Details noch frisch sind.

Wenn Sie zum Beispiel wissen, dass Sie und eine andere Person an unterschiedlichen Refactoring-Vorgängen arbeiten, die sich auf denselben Dateisatz auswirken, sollten Sie sich vorab mit den anderen besprechen und ein besseres Verständnis dafür bekommen, welche Art von Änderung jeder von Ihnen ist Herstellung. Sie können viel Zeit und Mühe sparen, wenn Sie Ihre geplanten Änderungen seriell statt parallel durchführen.

Bei größeren Refactorings, die einen großen Codebereich durchlaufen, sollten Sie unbedingt seriell arbeiten: Jeder hört auf, in diesem Bereich des Codes zu arbeiten, während eine Person das komplette Refactoring durchführt.

Wenn Sie nicht seriell arbeiten können (möglicherweise aufgrund von Zeitdruck), hilft Ihnen die Kommunikation über erwartete Zusammenführungskonflikte zumindest, wenn Sie die Probleme früher lösen, während die Details noch im Hinterkopf sind. Wenn zum Beispiel ein Mitarbeiter im Verlauf eines Zeitraums von einer Woche eine Reihe störender Commits eingeht, können Sie sich in dieser Woche ein- oder zweimal täglich auf dieser Zweigstelle zusammenlegen bzw. die Datenbank erneut zusammenführen. Auf diese Weise können Sie Konflikte beim Zusammenführen / Wiederherstellen schneller lösen, als wenn Sie ein paar Wochen warten, um alles in einem großen Klumpen zusammenzuführen.

Tipp fünf

Wenn Sie sich einer Zusammenführung nicht sicher sind, erzwingen Sie sie nicht.

Das Zusammenführen kann sich überwältigend anfühlen, insbesondere wenn viele Dateien in Konflikt stehen und die Konfliktmarkierungen Hunderte von Zeilen umfassen. Bei der Schätzung von Softwareprojekten nehmen wir oft nicht genügend Zeit für Overhead-Elemente ein, wie z. B. das Durchführen einer gnarly Merge. Es fühlt sich also an, als ob es sehr schwer wäre, mehrere Stunden damit zu verbringen, jeden Konflikt zu analysieren.

Langfristig zu planen und sich bewusst zu machen, woran andere arbeiten, ist das beste Werkzeug, um Zusammenführungskonflikte zu antizipieren und sich darauf vorzubereiten, sie in kürzerer Zeit richtig zu lösen.


Ich möchte entweder meine oder ihre Version vollständig oder möchte einzelne Änderungen überprüfen und für jede einzelne entscheiden.

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

Akzeptieren Sie ihre Version (Remote, ihre):

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

Wenn Sie alle Konfliktdateien ausführen möchten:

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 für beide Versionen eine der beiden Versionen.
  3. git add <filename>
  4. git commit -m "merged bla bla"

Das Standard- mergetool arbeitet in der Befehlszeile . Wie man ein Befehlszeilen-Mergetool verwendet, sollte eine separate Frage sein.

Sie können dazu auch ein visuelles Tool installieren, z. B. meld and run

git mergetool -t meld

Es wird die lokale Version (unsere), die "Basisversion" oder die "zusammengeführte" Version (das aktuelle Ergebnis der Zusammenführung) und die Remote-Version (ihre Version) geöffnet. Speichern Sie die zusammengeführte Version, wenn Sie fertig sind, führen Sie git mergetool -t meld erneut aus, bis "Keine Dateien müssen zusammengeführt werden". git mergetool -t meld Sie dann mit den Schritten 3 und 4 fort.


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

Ich denke, der eigentliche Schlüssel ist zu wissen, wie Änderungen mit lokalen und Remote-Repositories ablaufen. Der Schlüssel dazu ist das Verfolgen von Zweigen. Ich habe festgestellt, dass ich den Tracking-Zweig als das "fehlende Stück in der Mitte" sehe, zwischen meinem lokalen, aktuellen Dateiverzeichnis und dem als Ursprung definierten Remote.

Ich habe mich daran gewöhnt, zwei Dinge zu vermeiden, um dies zu vermeiden.

Anstatt:

git add .
git commit -m"some msg"

Was hat zwei Nachteile -

a) Alle neuen / geänderten Dateien werden hinzugefügt und dies kann einige unerwünschte Änderungen enthalten.
b) Sie können die Dateiliste nicht zuerst überprüfen.

Stattdessen mache ich:

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

Auf diese Weise sind Sie bewusster darüber, welche Dateien hinzugefügt werden, und Sie können auch die Liste überprüfen und ein wenig mehr darüber nachdenken, während Sie den Editor für die Nachricht verwenden. Ich finde, es verbessert auch meine Commit-Nachrichten, wenn ich anstelle der Option -m einen Vollbild-Editor verwende.

[Update - Mit der Zeit habe ich mehr zu:

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

]

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

git pull

oder

git pull origin master.

weil pull eine Zusammenführung impliziert und wenn Sie lokal Änderungen haben, die Sie nicht zusammengeführt haben möchten, können Sie leicht mit zusammengeführtem Code enden und / oder Konflikte für Code zusammenführen, der nicht zusammengeführt werden sollte.

Stattdessen versuche ich es zu tun

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

Sie können dies auch hilfreich finden:

Git-Zweig, Gabel, Holen, Zusammenführen, Rebase und Klon, was sind die Unterschiede?


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

git checkout . --ours

um Änderungen zugunsten Ihres Repository aufzulösen, oder

git checkout . --theirs

Änderungen zu Gunsten des anderen oder des Haupt-Repository auflösen.

Andernfalls müssen Sie ein GUI-Merge-Tool verwenden, um die Dateien nacheinander zu durchlaufen, sagen Sie, dass das Merge-Tool p4merge , oder schreiben Sie einen beliebigen Namen, den Sie bereits installiert haben

git mergetool -t p4merge

Nach dem Beenden einer Datei müssen Sie speichern und schließen, damit die nächste geöffnet wird.


Zusammenführungskonflikte treten auf, wenn gleichzeitig Änderungen an einer Datei vorgenommen werden. So lösen Sie es.

git CLI

Hier sind einfache Schritte, was Sie tun müssen, wenn Sie sich in einem Konflikt befinden:

  1. Unmerged paths Sie sich die Liste der in Konflikt stehenden Dateien mit: git status (im Abschnitt Unmerged paths ).
  2. Lösen Sie die Konflikte für jede Datei nach einer der folgenden Methoden:

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

    • Um die Remote- / andere Version zu akzeptieren, verwenden Sie: git checkout --theirs path/file . Dadurch werden alle lokalen Änderungen für diese Datei abgelehnt.

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

      Sie müssen jedoch vorsichtig sein, da Änderungen aus der Ferne aus irgendeinem Grund Konflikte verursacht haben.

      Verwandte: Was ist die genaue Bedeutung von "uns" und "ihrer" in git?

    • Bearbeiten Sie die konfliktierten Dateien manuell und suchen Sie nach dem Codeblock zwischen <<<<< / >>>>> Wählen >>>>> dann die Version entweder oben oder unten aus ===== . Siehe: Darstellung von Konflikten .

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

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

    Wenn sich 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 .

  4. Wenn alle Konflikte erfolgreich gelöst wurden, übergeben Sie die Änderungen wie git commit -a : git commit -a und drücken Sie wie gewohnt auf Remote.

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

DiffMerge

Ich habe erfolgreich DiffMerge das Dateien unter Windows, Mac OS und Linux / Unix visuell vergleichen und zusammenführen kann.

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

Bildquelle: DiffMerge (Linux-Screenshot)

Einfach herunterladen und als Repo ausführen:

git mergetool -t diffmerge .

Mac OS

Auf macOS können Sie installieren über:

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

Und wahrscheinlich (falls nicht angegeben) benötigen Sie den folgenden einfachen einfachen Wrapper in Ihrem PATH (zB /usr/bin ):

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

Dann können Sie die folgenden Tastenkombinationen verwenden:

  • Alt - Alt - Auf / Ab, um zu vorherigen / nächsten Änderungen zu springen.
  • Alt - Alt - Links / Rechts , um die Änderung von links oder rechts zu akzeptieren

Alternativ können Sie opendiff (Teil von Xcode Tools) verwenden, mit dem Sie zwei Dateien oder Verzeichnisse zusammenführen können, um eine dritte Datei oder ein Verzeichnis zu erstellen.


git merge zur Darstellung von Konflikten finden Sie in Git oder in der Dokumentation zum Zusammenführen von Git, git merge zu verstehen, welche Markierungen für Zusammenführungskonflikte bestehen.

Im Abschnitt So lösen Sie Konflikte auf, erfahren Sie auch , wie Sie Konflikte lösen können:

Nachdem Sie einen Konflikt gesehen haben, können Sie zwei Dinge tun:

  • Entscheide dich, nicht zu verschmelzen. Sie müssen lediglich die Indexdatei auf das HEAD Commit zurücksetzen, um die 2. Datei rückgängig zu machen, und die Änderungen in der Arbeitsstruktur bereinigen, die von 2. und 3. vorgenommen wurden .; git merge --abort kann hierfür verwendet werden.

  • Lösen Sie die Konflikte. Git markiert die Konflikte im Arbeitsbaum. Bearbeiten Sie die Dateien in Form und git add sie zum Index hinzu. Verwenden Sie git commit , um den Deal zu besiegeln.

Sie können den Konflikt mit einer Reihe von Tools durcharbeiten:

  • Verwenden Sie ein Mergetool. git mergetool , um ein grafisches git mergetool zu starten, das Sie durch die Zusammenführung führt.

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

  • Schauen Sie sich die Unterschiede von jedem Zweig an. git log --merge -p <path> zeigt zuerst die Unterschiede 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 HEAD Version und git show :3:filename zeigt die MERGE_HEAD Version.

Informationen zum Zusammenführen von Konfliktmarken und deren Behebung finden Sie im Pro Git -Buchabschnitt Grundlegende Zusammenführungskonflikte .


Für diejenigen, die Visual Studio verwenden (2015 in meinem Fall)

  1. Schließen Sie Ihr Projekt in VS. Insbesondere in großen Projekten neigt VS dazu, beim Zusammenführen mit der Benutzeroberfläche auszuflippen.

  2. Führen Sie die Eingabeaufforderung zum Zusammenführen aus.

    git checkout target_branch

    git merge source_branch

  3. Öffnen Sie dann das Projekt in VS und gehen Sie zu Team Explorer -> Branch. Nun gibt es eine Meldung, die besagt, dass die Zusammenführung anhängig ist, und in Konflikt stehende Dateien werden direkt unter der Meldung angezeigt.

  4. Klicken Sie auf die in Konflikt stehende Datei, und Sie haben die Option Zusammenführen, Vergleichen, Quelle übernehmen und Ziel übernehmen. Das Zusammenführungswerkzeug in VS ist sehr einfach zu verwenden.


Ich folge dem untenstehenden Prozess.

Der Prozess zum Beheben von Zusammenführungskonflikten:

  1. Ziehen Sie zuerst das neueste aus dem Zielzweig, zu dem Sie die Zusammenführung durchführen möchten git pull origin develop

  2. Wenn Sie das neueste vom Ziel erhalten, lösen Sie den Konflikt nun manuell in der IDE, indem Sie diese zusätzlichen Zeichen löschen.

  3. Sie ein , git adddiese bearbeiteten Dateien an die git - Warteschlange hinzufügen , so dass es sein kann , commitund pushauf die gleiche Branche Sie arbeiten.

  4. Wie git addgeschieht, tun ein , git commitdie Änderungen zu übernehmen.

  5. Schieben Sie nun die Änderungen an Ihrem Arbeitszweig vorbei git push origin HEAD

Wenn Sie Bitbucket oder GitHub verwenden, wird dies in Ihrer Pull-Anfrage behoben.


Versuchen Sie: git mergetool

Es öffnet sich eine GUI, die Sie schrittweise durch die einzelnen Konflikte führt, und Sie können auswählen, wie die Zusammenführung erfolgen soll. Manchmal erfordert es nachträglich ein wenig Handbearbeitung, aber normalerweise reicht es für sich aus. Es ist viel besser, als das Ganze sicher von Hand zu machen.

Wie im Kommentar von @JoshGlover:

Der Befehl öffnet nicht unbedingt eine GUI, es sei denn, Sie installieren eine. Das Ausführen von git mergetool für mich führte vimdiff , dass vimdiff verwendet wurde. 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. Basierend auf diesem 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 zum Zusammenführen 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 Ansichten sind

LOCAL - Dies ist eine Datei aus dem aktuellen Zweig

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

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

MERGED - Merge-Ergebnis, dies wird im Repo gespeichert

Sie können mit ctrl+w zwischen diesen Ansichten navigieren. Sie erreichen die MERGED-Ansicht direkt mit ctrl+w gefolgt von j .

Weitere Informationen zur Navigation von vimdiff here und here

Schritt 4 Sie können die MERGED-Ansicht folgendermaßen 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, bestätigen und bereinigen

:wqa speichern und verlassen von vi

git commit -m "message"

git clean Entfernt zusätzliche Dateien (zB * .orig), die mit dem diff-Tool erstellt wurden.


Wenn Sie als IDE intelliJ verwenden Versuchen Sie, das übergeordnete Element mit Ihrem Zweig zu verbinden

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

Es werden alle Konflikte so angezeigt

A_MBPro: test anu $ git merge origin / Automatisch zusammenführen von src / test / java / com /.../ TestClass.java CONFLICT (Inhalt): Konflikt in src / test / java / com /.../ TestClass.java zusammenführen

Beachten Sie nun, dass die Datei TestClass.java in intelliJ rot angezeigt wird. Auch der git-Status wird angezeigt

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

Öffnen Sie die Datei in intelliJ, sie enthält Abschnitte mit

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

wobei HEAD Änderungen in Ihrem lokalen Zweig und Ursprung / Änderungen vom entfernten Zweig vorgenommen werden. Behalten Sie hier das Zeug, das Sie brauchen, und entfernen Sie das, was Sie nicht brauchen. Danach sollten die normalen Schritte ausgeführt werden. Das ist

   git add TestClass.java
   git commit -m "commit message"
   git push

Zusammenführungskonflikte können in verschiedenen Situationen auftreten:

  • Wenn "git fetch" und dann "git merge" ausgeführt wird
  • Wenn "git fetch" und dann "git rebase" ausgeführt wird
  • Beim Ausführen von "git pull" (was tatsächlich einer der oben genannten Bedingungen entspricht)
  • Beim Ausführen von "Git Stash Pop"
  • Wenn Sie Git-Patches anwenden (Commits, die zum Übertragen in Dateien exportiert werden, z. B. per E-Mail)

Sie müssen ein Merit-Tool installieren, das mit Git kompatibel ist, um die Konflikte zu lösen. Ich persönlich benutze KDiff3, und ich fand es schön und praktisch. Sie können die Windows-Version hier herunterladen:

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

Übrigens, wenn Sie Git Extensions installieren, gibt es im Setup-Assistenten eine Option zur Installation von Kdiff3.

Dann richten Sie git configs ein, um Kdiff als Mergetool zu verwenden:

$ 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

(Denken Sie daran, den Pfad durch den tatsächlichen Pfad der Kdiff-Exe-Datei zu ersetzen.)

Jedes Mal, wenn Sie auf einen Zusammenführungskonflikt stoßen, müssen Sie nur diesen Befehl ausführen:

$git mergetool

Dann öffnet es den Kdiff3 und versucht zuerst, die Zusammenführungskonflikte automatisch zu lösen. Die meisten Konflikte werden spontan gelöst, und Sie müssen den Rest manuell beheben.

So sieht Kdiff3 aus:

Wenn Sie fertig sind, speichern Sie die Datei, und es wird zur nächsten Datei mit Konflikten weitergegangen, und Sie machen dasselbe wieder, bis alle Konflikte gelöst sind.

Um zu überprüfen, ob alles erfolgreich zusammengeführt wurde, führen Sie einfach den Befehl mergetool erneut aus. Sie sollten folgendes Ergebnis erhalten:

$git mergetool
No files need merging

Ab dem 12. Dezember 2016 können Sie Filialen zusammenführen und Konflikte auf github.com lösen

Wenn Sie also nicht die Befehlszeile oder andere Tools von Drittanbietern verwenden möchten, die hier aus älteren Antworten angeboten werden , verwenden Sie das native Tool von GitHub.

In diesem Blog-Beitrag wird ausführlich erläutert. Wenn Sie jedoch zwei Zweige über die Benutzeroberfläche "zusammenführen", sehen Sie nun die Option "Konflikte lösen", mit der Sie zu einem Editor gelangen, mit dem Sie diese Zusammenführungskonflikte bearbeiten können.


Versuchen Sie es mit Visual Studio Code, wenn Sie es noch nicht getan haben. Nach dem Zusammenführen (und Zusammenführen in Zusammenführungskonflikten) versucht der VS-Code die Zusammenführungskonflikte automatisch.

Es kann Ihnen sehr gut helfen , indem sie zeigen , was die Änderungen an der ursprünglichen gemacht und sollten Sie akzeptieren incomingoder

current change (bedeutet Original vor dem Zusammenführen) '?.

Es hat mir geholfen und es kann auch für Sie funktionieren!

PS: Es funktioniert nur, wenn Sie git mit Ihrem Code und Visual Studio-Code konfiguriert haben.


git checkout branch1

git fetch origin

git rebase -p origin/mainbranch

Wenn es Zusammenführungskonflikte gibt, beheben Sie diese. Fahren Sie dann mit dem Rebase-Prozess fort, indem Sie Folgendes ausführen:git rebase –-continue

Nach der Behebung können Sie Ihre lokale Zweigstelle festschreiben und in eine entfernte Zweigstelle verschieben

git push origin branch1






git-conflict-resolution