Zum Inhalt springen
SONOYA.com
Selfhosting & Web

Git-Konflikte lösen: Merge, Rebase und Notbremse

Git meldet CONFLICT oder lehnt den Push ab? So löst Du Merge-Konflikte, brichst Rebase sicher ab und rettest verlorene Commits mit git reflog.

Von

Symbol zweier zusammenlaufender Git-Zweige auf dunklem Verlauf als Bild für das Lösen von Merge-Konflikten

Irgendwann steht im Terminal CONFLICT (content): Merge conflict in config.yml, der Push wird mit rejected abgelehnt, oder ein git reset hat gerade einen Commit verschluckt. In diesem Moment hilft keine Git-Theorie, sondern nur die Antwort auf zwei Fragen: Wie komme ich hier sauber raus, und wie mache ich danach richtig weiter? Dieser Artikel beantwortet beides für die Situationen, die im Alltag am häufigsten vorkommen, und endet mit der Notbremse, die fast jeden Fehler rückgängig macht.

Alle Befehle und Ausgaben stammen aus einem Test-Repository mit Git 2.54 am Mac. Unter Linux und Windows sind Befehle und Meldungen identisch.

Einen Merge-Konflikt lesen und lösen

Ein Konflikt entsteht, wenn zwei Zweige dieselbe Zeile unterschiedlich geändert haben. Git kann dann nicht entscheiden, welche Version gilt, und überlässt Dir die Wahl. Im Test hatte der Zweig main den Port auf 5000 gesetzt, der Zweig feature auf 8080:

Code
$ git merge feature
Auto-merging config.yml
CONFLICT (content): Merge conflict in config.yml
Automatic merge failed; fix conflicts and then commit the result.

Welche Dateien betroffen sind, zeigt git status unter Unmerged paths mit dem Vermerk both modified. Öffne die Datei im Editor. Git hat beide Versionen hineingeschrieben und mit Markierungen getrennt:

Code
<<<<<<< HEAD
port: 5000
=======
port: 8080
>>>>>>> feature
host: localhost

Oberhalb von ======= steht Deine aktuelle Version (HEAD, also der Zweig, auf dem Du gerade bist), darunter die Version, die Du hereinholst, hier aus feature. Lösch die drei Markierungszeilen und behalte, was richtig ist: eine der beiden Zeilen, beide oder eine neue Mischung. Danach darf in der Datei kein <<<<<<<, ======= oder >>>>>>> mehr stehen.

Markiere die Datei als gelöst und schließ den Merge ab:

Code
git add config.yml
git commit

Git schlägt eine fertige Commit-Nachricht wie Merge branch 'feature' vor, die Du im Editor nur bestätigen musst. Bei mehreren Dateien wiederholst Du das Bearbeiten und git add für jede, bevor Du committest.

In VS Code geht das bequemer. Über jedem Konfliktblock stehen klickbare Optionen: „Accept Current Change“ übernimmt Deine Version, „Accept Incoming Change“ die hereinkommende, „Accept Both Changes“ beide untereinander. In der deutschen Oberfläche heißen sie sinngemäß aktuelle, eingehende und beide Änderungen annehmen. Nach dem Klick speicherst Du die Datei und machst im Terminal mit git add weiter. Wie Du Git und VS Code am Mac einrichtest, steht in Mac für Entwickler einrichten: der Leitfaden für 2026.

Die Notbremse: —abort

Bist Du mitten im Konflikt und merkst, dass Du gerade den falschen Zweig zusammenführst, brichst Du einfach ab:

Code
git merge --abort

Das Repository steht danach exakt so da wie vor dem git merge, und git status --short zeigt keine Änderungen mehr. Dasselbe gibt es für einen Rebase (git rebase --abort) und für das Übernehmen einzelner Commits (git cherry-pick --abort). Welche Notbremse gerade gilt, verrät Dir git status: Die Meldung nennt den passenden Befehl in der Zeile (use "git merge --abort" to abort the merge).

Merge oder Rebase, in einfachen Worten

Beide Befehle bringen die Änderungen aus zwei Zweigen zusammen, nur auf unterschiedliche Art:

  • Merge lässt beide Zweige, wie sie sind, und verbindet sie mit einem zusätzlichen Merge-Commit. Die Geschichte bleibt vollständig, wird aber verzweigter.
  • Rebase nimmt Deine Commits und setzt sie nacheinander oben auf den anderen Zweig, als hättest Du erst danach angefangen. Die Geschichte wird eine gerade Linie, Deine Commits bekommen dabei aber neue Kennungen.

Als Faustregel: Für Deinen eigenen, noch nicht geteilten Zweig ist Rebase angenehm. Einen Zweig, den andere schon heruntergeladen haben, rebasest Du nicht, sondern führst ihn per Merge zusammen.

Auch beim Rebase kann es Konflikte geben, weil Git jeden Commit einzeln neu anwendet:

Code
$ git rebase main
CONFLICT (content): Merge conflict in config.yml
error: could not apply 35bdbb5... Port 8080

Du löst den Konflikt genauso wie oben, schließt aber nicht mit git commit ab, sondern mit:

Code
git add config.yml
git rebase --continue

Git wendet dann den nächsten Commit an, bis alle durch sind. Eine Falle beim Rebase: Die Rollen in den Markierungen sind vertauscht. HEAD ist hier der Zweig, auf den Du aufsetzt, also main, und Deine eigene Änderung steht unten. Lies die Blöcke deshalb genau, bevor Du in VS Code „Accept Current Change“ klickst.

Push abgelehnt: rejected und diverged

Die zweite Klassiker-Meldung kommt beim Hochladen:

Code
$ git push origin main
 ! [rejected]        main -> main (fetch first)
error: failed to push some refs to '...'
hint: Updates were rejected because the remote contains work that you do not
hint: have locally.

Auf dem Server liegt ein Commit, den Du noch nicht hast, etwa von einem Kollegen oder von Dir selbst auf einem anderen Rechner. git status meldet nach einem git fetch dann Your branch and 'origin/main' have diverged. Hol die Änderungen und setz Deine darauf:

Code
git pull --rebase
git push

Gibt es dabei Konflikte, löst Du sie wie im Rebase-Abschnitt. Ein einfaches git pull ohne Option bricht in aktuellen Git-Versionen bei auseinandergelaufenen Zweigen mit fatal: Need to specify how to reconcile divergent branches. ab. Leg das Verhalten einmal dauerhaft fest, dann reicht künftig git pull:

Code
git config --global pull.rebase true

Was Du in dieser Situation nicht tun solltest, ist git push --force. Das überschreibt die Commits auf dem Server, und die Arbeit des anderen ist weg. Musst Du nach einem Rebase Deines eigenen Zweigs wirklich überschreiben, nimm git push --force-with-lease. Diese Variante bricht ab, wenn auf dem Server inzwischen etwas Neues liegt, das Du noch nicht kennst.

Den letzten Commit ändern oder rückgängig machen

Welcher Befehl der richtige ist, hängt vor allem an einer Frage: Ist der Commit schon gepusht?

Noch nicht gepusht, Nachricht oder Inhalt korrigieren. Vergessene Datei mit git add hinzufügen, dann:

Code
git commit --amend -m "Neue Nachricht"

Der letzte Commit wird durch eine korrigierte Fassung ersetzt.

Noch nicht gepusht, Commit zurücknehmen, Änderungen behalten. Der Commit verschwindet, die Dateien bleiben geändert und vorgemerkt, sodass Du neu committen kannst:

Code
git reset --soft HEAD~1

Schon gepusht. Hier änderst Du die Geschichte nicht mehr, sondern erzeugst einen Gegen-Commit, der die Änderung umkehrt:

Code
git revert HEAD

Git legt einen neuen Commit mit der Nachricht Revert "..." an, den Du ganz normal pushst. Das ist der einzige sichere Weg, wenn andere den Commit schon haben.

Vorsicht mit git reset --hard. Der Befehl setzt den Zweig zurück und verwirft dabei alle Änderungen, die noch nicht committet sind, ohne Rückfrage. Commits lassen sich danach retten, nicht committete Änderungen nicht.

Die Rettung: git reflog

Git merkt sich lokal jede Bewegung von HEAD, auch Resets, Rebases und gelöschte Zweige. Hast Du einen Commit „verloren“, zeigt git reflog den Weg zurück. Im Test hatte ein git reset --hard HEAD~2 zwei Commits entfernt:

Code
$ git reflog
b338ba5 HEAD@{0}: reset: moving to HEAD~2
8c53282 HEAD@{1}: commit (amend): Revert korrigiert
4dc4d61 HEAD@{2}: revert: Revert "Andere Datei"

Die oberste Zeile ist der Reset, die Zeile darunter der Zustand direkt davor. Mit dessen Kennung springst Du zurück:

Code
git reset --hard HEAD@{1}

Danach zeigt git log --oneline -1 wieder 8c53282 Revert korrigiert, und beide Commits sind zurück. Bist Du unsicher, welcher Eintrag der richtige ist, leg statt des Resets erst einen Rettungszweig an, zum Beispiel mit git branch rettung 8c53282, und schau ihn Dir in Ruhe an. Der Reflog ist rein lokal und hält Einträge zu verlorenen Commits standardmäßig 30 Tage, für einen frischen Fehler ist er also fast immer da.

Wenn Du diese drei Werkzeuge kennst, verlieren Git-Fehlermeldungen ihren Schrecken: --abort bringt Dich aus jedem halbfertigen Merge oder Rebase heraus, revert korrigiert, was schon geteilt ist, und reflog findet, was Du lokal verloren glaubst. Wer seine Repositories lieber auf dem eigenen Server statt bei GitHub hält, findet den Einstieg in Forgejo: eigener Git-Server mit Docker statt GitHub.

Weiterlesen.