Git Cherry-Pick: Wie man bestimmte Commits auswählt und anwendet

Syntax von Git Cherry-Pick

Um diesen Befehl effektiv zu nutzen, ist es wichtig, die Syntax von git cherry-pick zu verstehen. Es geht nicht nur um die Auswahl von Commits, sondern auch darum, sie präzise anzuwenden, um das gewünschte Ergebnis zu erzielen.

Die grundlegende Syntax für das Cherry-Picking eines einzelnen Commits lautet:

git cherry-pick <commit-hash>

• git cherry-pick: Der Befehl, der den Vorgang einleitet.
• : Die eindeutige Kennung (SHA-1-Hash) des Commits, den du herauspicken willst. Diesen Hash kannst du finden, indem du git log aufrufst, um den Commit-Verlauf aufzulisten.

Wenn du den obigen Befehl ausführst, wendet Git die Änderungen aus dem angegebenen Commit auf den aktuellen Zweig an und erstellt einen neuen Commit mit denselben Änderungen, aber einem anderen Hash. 

Es ist wichtig zu wissen, dass der Befehl nur den Commit selbst überträgt, nicht aber den Kontext oder die übergeordnete Geschichte des ursprünglichen Zweigs.

Neu bei Git und GitHub? In diesemginnerfreundlichen GitHub- und Git-Tutorial kannst du mit der Versionskontrolle beginnen.

So benutzt du Git Cherry-Pick: Schritt-für-Schritt-Beispiele

Nachdem du nun die grundlegende Syntax von git cherry-pick verstanden hast, ist es an der Zeit, den Befehl in Aktion zu sehen.

In diesem Abschnitt findest du praktische Beispiele, die dich durch gängige grundlegende und komplexere Szenarien führen, in denen Cherry-Picking sinnvoll ist. Jedes Beispiel zeigt, wie du die Änderungen von einem oder mehreren Commits auf einen anderen Zweig anwendest. 

Beispiel 1: Einen einzelnen Commit herauspicken

Angenommen, du hast eine Korrektur in einem Funktionszweig vorgenommen, die du auf den Hauptzweig übertragen möchtest, ohne den gesamten Funktionszweig zusammenzuführen.

• Finde zunächst den Hash des Commits, den du dir herauspicken möchtest, indem du ihn ausführst:

git log

• Finde den Hash des Commits. 
• Wechsle zum Hauptzweig:

git checkout main

• Führe den Befehl cherry-pick aus (gehe davon aus, dass der Hash abc1234 ist):

git cherry-pick abc1234

Wenn du diesen Befehl ausführst, wendet Git die Änderungen aus dem Commit, der durch abc1234 identifiziert wurde, auf deinen aktuellen Zweig an (in diesem Fall ist das main ). Git erstellt einen neuen Commit auf dem Hauptzweig, der die gleichen Änderungen wie der ursprüngliche Commit enthält, aber mit einem neuen Commit-Hash.

Beispiel 2: Rosinenpicken mehrerer Commits

In manchen Situationen musst du mehrere verschiedene Commits von einem Branch auf einen anderen übertragen. Angenommen, du hast drei verschiedene Commits in deinem Feature-Branch, die du in den Main-Branch bringen musst.

• Finde die Commit-Hashes für jeden Commit, den du dir herauspicken willst, mit git log:

git log

• Wechsle zum Hauptzweig:

git checkout main

• Führe den Befehl cherry-pick aus und liste die Commits auf:

git cherry-pick abc1234 def5678 ghi7890

Beispiel 3: Eine Auswahl an Commit-Bereichen treffen

Angenommen, du hast eine Reihe von Commits auf dem Feature-Branch gemacht und möchtest sie in einem Rutsch auf den Main Branch übertragen, ohne jeden Commit einzeln anzugeben. Wie würdest du es machen?

• Verwende git log, um die Start- und End-Commits zu kennzeichnen, die du herauspicken möchtest (z.B. abc1234 bis ghi7890).
• Wechsle zum Hauptzweig:

git checkout main

• Führe den Befehl cherry-pick mit einem Commit-Bereich aus:

git cherry-pick abc1234...ghi7890

Beispiel 4: Einen Commit aus einem entfernten Zweig herauspicken

Manchmal gibt es eine kritische Korrektur in einem entfernten Zweig und du möchtest sie in deinem lokalen Zweig anwenden, ohne den gesamten Zweig zusammenzuführen. So geht's:

• Holt die neuesten Änderungen aus dem entfernten Repository

git fetch origin

• Listet die Commits im Remote-Zweig auf, um den Hash zu finden, den ihr braucht:

git log origin/feature_branch --oneline

• Angenommen, der benötigte Commit-Hash lautet abc1234.
• Wechsle zu deiner örtlichen Hauptfiliale:

git checkout main

• Nimm den Commit aus dem entfernten Zweig mit:

git cherry-pick abc1234

So kannst du einen Commit aus einem entfernten Zweig anwenden, ohne den gesamten Zweig zusammenzuführen.

Musst du eine entfernte Filiale überprüfen? Folge dieser Schritt-für-Schrittp Anleitung zum Git Checkout für entfernte Zweige.

Beispiel 5: Einen Commit herauspicken und ihn modifizieren

Wenn du einen Commit auswählst, aber vor dem Commit noch kleine Änderungen vornehmen musst, kannst du den interaktiven Modus von Git verwenden. Und so geht's:

• Wechsle zum Zielzweig:

git checkout main

• Wähle den Commit aus, aber stoppe ihn vor dem Commit:

git cherry-pick -n abc1234

Das -n (oder --no-commit) Flag wendet die Änderungen an, erstellt aber keinen Commit.

• Ändere die Dateien nach Bedarf.
• Stufe und bestätige die Änderungen manuell:

git add .
git commit -m "Modified cherry-picked commit from feature_branch"

Das ist nützlich, wenn du einen ausgewählten Commit vor der Fertigstellung noch einmal überarbeiten musst.

Umgang mit Konflikten beim Git Cherry-Pick

Konflikte sind unvermeidlich, wenn du Commits zwischen Zweigen auswählst, vor allem, wenn die Codebasis stark voneinander abgewichen ist. 

cherry-pick ist zwar so konzipiert, dass Änderungen sauber übernommen werden, kann aber Unterschiede nicht immer automatisch ausgleichen. In diesen Fällen müssen die Konflikte manuell gelöst werden. Zu verstehen, wie Konflikte entstehen und wie man mit ihnen umgeht, ist entscheidend für den Abschluss einer cherry-pick Operation.

Wie Konflikte entstehen

Konflikte treten in der Regel auf, wenn sich die Änderungen aus dem Cherry-Picked-Commit mit Änderungen überschneiden, die bereits im Zielzweig vorhanden sind, oder diesen widersprechen. Zum Beispiel:

• Dieselbe Zeile wurde in beiden Zweigen geändert: Wenn dieselbe Codezeile sowohl im Quell- als auch im Zielzweig geändert wird, weiß Git nicht, welche Version es anwenden soll.
• Datei in einem Zweig gelöscht, aber in einem anderen geändert: Wenn eine Datei in einem Zweig gelöscht, aber im Cherry-Picked-Commit geändert wird, weiß Git nicht, ob es die Datei behalten oder die Änderungen übernehmen soll.
• Unveränderte Änderungen, aber dieselbe Datei: Auch wenn die Änderungen scheinbar nichts miteinander zu tun haben, kann Git sie als potenziellen Konflikt kennzeichnen, wenn sie in derselben Datei vorkommen.

Wenn ein Konflikt auftritt, stoppt Git den Vorgang cherry-pick und lässt dein Arbeitsverzeichnis in einem Konfliktzustand zurück, der vor dem Fortfahren aufgelöst werden muss.

Konflikte lösen

Sobald ein Konflikt auftritt, zeigt Git die widersprüchlichen Dateien an, und du musst die Unstimmigkeiten manuell auflösen. Hier erfährst du, wie du Konflikte lösen kannst:

1. Überprüfe die widersprüchlichen Dateien: Führe den folgenden Befehl aus, um zu sehen, welche Dateien in Konflikt stehen:

git status

Der Befehl zeigt die Liste der Dateien mit Konflikten an. 

2. Löse die Konflikte: Du kannst die widersprüchlichen Dateien manuell bearbeiten, um die Probleme zu lösen. Entferne die Konfliktmarkierungen (<<<<<<<, =======, >>>>>>>) und entscheide, welche Änderungen du beibehalten oder wie du sie kombinieren willst.

3. Verwende das Git Mergetool (optional): Wenn das manuelle Lösen von Konflikten mühsam ist, kannst du ein Zusammenführungswerkzeug verwenden, das dich bei der Visualisierung und Lösung von Konflikten unterstützt:

git mergetool

Je nach Konfiguration öffnet das obige Tool ein visuelles Zusammenführungswerkzeug, das die Überprüfung und Lösung von Konflikten erleichtert.

4. Markiere die Konflikte als gelöst: Nachdem du die Konflikte gelöst hast, markiere die Dateien als gelöst mit:

git add <conflicted-file>

5. Schließe die Kirschpflückung ab: Sobald alle Konflikte gelöst und die Dateien bereitgestellt sind, beendest du den Cherry-Pick, indem du ihn ausführst:

git cherry-pick --continue

Viele moderne IDEs und Tools, wie z.B. Visual Studio Code und GitHub, bieten integrierte Funktionen zur Lösung von Konflikten beim Zusammenführen. Die Weboberfläche von GitHub ermöglicht es dir, Konflikte direkt in Pull Requests zu lösen, was die Zusammenarbeit an gemeinsamen Repositories erleichtert, ohne dass du in eine lokale Umgebung wechseln musst.

Überspringen eines Commits nach einem Konflikt

Manchmal kann es sein, dass die Lösung eines Konflikts zu komplex ist oder dass du feststellst, dass die Verpflichtung gar nicht notwendig ist. In solchen Fällen kannst du den Commit ganz überspringen.

1. Brich den aktuellen Cherry-Pick-Prozess ab: Wenn der Konflikt zu kompliziert ist und du den Commit nicht anwenden willst, kannst du ihn überspringen, indem du ihn ausführst:

git cherry-pick --skip

Dadurch wird der konfliktbehaftete Commit verworfen und mit dem nächsten fortgefahren (wenn du mehrere Commits auswählst).

2. Brich die gesamte Rosinenpickerei ab: Wenn du den Vorgang cherry-pick ganz abbrechen möchtest, kannst du ihn ausführen:

git cherry-pick --abort

Mit diesem Befehl wird dein Arbeitsverzeichnis in den Zustand zurückversetzt, in dem es war, bevor du den Cherry-Pick gestartet hast. 

Du willst deinen Commit-Verlauf bereinigen? In diesem Git-Squash-Tutorial erfährst du, wie du mehrere Commits zu einem zusammenfassen kannst.

Best Practices für die Verwendung von Git Cherry-Pick

Die falsche Verwendung von cherry-pick kann zu komplizierten Verläufen und Verwirrung in der Versionskontrolle deines Projekts führen. Um diese Fallstricke zu vermeiden, solltest du dich an die Best Practices halten, damit du cherry-pick effektiv nutzen kannst, ohne deine Codebasis unnötig zu verkomplizieren.

Halte es klein und spezifisch

Cherry-Picking ist am effektivsten, wenn es für kleine, spezifische Commits verwendet wird, die klar definierte Aufgaben betreffen, wie z.B. Bugfixes oder kleinere Funktionserweiterungen. 

Vermeide große, komplexe Commits, die mehrere Änderungen bündeln, da dies zu Konflikten führen und die Verwaltung der Codebasis erschweren kann. Je gezielter die Verpflichtung, desto einfacher ist es, sie ohne unerwünschte Nebenwirkungen anzuwenden.

Dokumentiere deine Rosinenpickerei

Um eine klare Geschichte zu erhalten, solltest du immer den richtigen Kontext angeben, wenn du eine Auswahl triffst. Dies kann durch detaillierte Commit-Meldungen oder Anmerkungen in der Dokumentation geschehen. 

Das Wichtigste ist, dass du erklären musst, warum eine Auswahl notwendig war. Das ist besonders wichtig, wenn du in langlebigen Zweigen oder kollaborativen Umgebungen die Rosinen herauspickst, denn so können zukünftige Mitwirkende besser verstehen, warum die Änderungen selektiv vorgenommen wurden.

Überprüfe den Commit-Verlauf

Bevor du dir die Rosinen herauspickst, solltest du die Commit-Historie des Quell- und des Zielzweigs überprüfen. Mit diesem Schritt kannst du feststellen, ob der Commit, den du auswählen willst, von anderen Änderungen abhängt. Fehlende Abhängigkeiten können zu unvollständigen Funktionen oder Fehlern führen, also stelle sicher, dass der Cherry-Pick keine unausgereiften Funktionen oder Updates einführt.

Vermeiden Sie die übermäßige Verwendung von Rosinenpickerei

Das Cherry-Picking ist zwar praktisch, um bestimmte Änderungen zu übernehmen, aber wenn du es übertreibst, kann es zu einer fragmentierten Geschichte mit doppelten Commits in verschiedenen Zweigen führen. Das kann es schwierig machen, den Ursprung bestimmter Veränderungen nachzuvollziehen oder den breiteren Entwicklungskontext zu verstehen. 

Wäge immer ab, ob Zusammenführen oder Umbasieren die bessere Strategie ist, bevor du dir die Rosinen herauspickst. Verwende cherry-pick sparsam und gezielt, um die Commit-Historie nicht zu überladen.

Hast du Probleme mit unnötigen Dateien in Git? Lerne mit in diesem Git Ignore Tutorial, wie du .gitignore effektiv nutzen kannst.

Fehlersuche bei häufigen Problemen mit Git Cherry-Pick

Die Behebung von Problemen, die bei der Verwendung von cherry-pick auftreten, erfordert ein klares Verständnis der zugrunde liegenden Mechanismen von Git. In diesem Abschnitt gehe ich auf einige häufige Probleme ein, auf die du bei der Rosinenpickerei stoßen kannst, und zeige dir, wie du sie lösen kannst.

Einen Commit auswählen, der nicht existiert

Manchmal kann es vorkommen, dass du versuchst, einen Commit zu wählen, der im aktuellen Zweig nicht zugänglich ist oder bereits zusammengeführt wurde. Dies führt normalerweise zu einer Fehlermeldung, die besagt, dass der Commit nicht gefunden oder angewendet werden konnte.

1. Commit nicht gefunden: Das passiert, wenn der Commit-Hash, den du dir herauspicken willst, in deinem aktuellen Repository oder Branch-Kontext nicht existiert. Stelle sicher, dass du auf den richtigen Commit verweist, indem du die Commit-Historie mit git log auf dem Zweig überprüfst, in dem der Commit existiert. Lösung:

• Überprüfe den Commit-Hash noch einmal, um sicherzustellen, dass er korrekt ist.
• Überprüfe, ob der Commit in einem Zweig existiert, auf den du Zugriff hast.
• Wenn die Übergabe in einem entfernten Zweig stattfindet, stelle sicher, dass der Zweig mit git fetch geholt wurde.

2. Commit bereits angewendet: Wenn der Commit bereits in den Zielzweig zusammengeführt oder gepickt wurde, verhindert Git, dass du ihn duplizierst. So bleibt der Verlauf sauber und überflüssige Änderungen werden vermieden. Lösung:

• Verwende git log, um zu prüfen, ob der Commit bereits im Zielzweig ist.
• Falls nötig, überspringe den Vorgang cherry-pick, da die Änderungen bereits übernommen wurden.

Rosinenpickerei nach einem Rebase oder einer Zusammenführung

Cherry-Picking nach einem Rebase oder Merge kann aufgrund der veränderten Historie deiner Zweige zu Problemen führen. Beim Rebasing wird die Commit-Historie neu geschrieben, während beim Merging Zweige zusammengeführt werden.

1. Konflikte aufgrund von Rebased Commits: Nach einem Rebase wird die Commit-Historie neu geschrieben, was zu Problemen führen kann, wenn du versuchst, Commits herauszupicken, die während des Rebase-Prozesses geändert wurden. Es kann zu Konflikten kommen, wenn cherry-pick versucht, Änderungen anzuwenden, die nicht mit der neu geschriebenen Geschichte übereinstimmen. Lösung:

• Überprüfe die Commit-Historie nach einem Rebase mit git log sorgfältig, um sicherzustellen, dass der Commit, den du dir herauspicken willst, nicht bereits geändert wurde.
• Löse Konflikte wie in einem normalen cherry-pick Prozess, indem du git status und manuelle Bearbeitungen verwendest.

2. Doppelte Commits nach einer Zusammenführung: Das Zusammenführen von Zweigen kann dazu führen, dass ein Commit, den du dir herauspicken willst, bereits in der zusammengeführten Geschichte enthalten ist. Ein erneutes Herauspicken kann zu doppelten Commits führen, die deinen Lernpfad durcheinander bringen und es schwierig machen, Änderungen nachzuvollziehen. Lösung:

• Vor dem Cherry-Picking solltest du den Commit-Verlauf beider Zweige überprüfen, um festzustellen, ob der Commit bereits zusammengeführt wurde.
• Vermeide es, denselben Commit zu wählen, wenn er bereits im Zielzweig ist.

Willst du Änderungen in Git rückgängig machen? Erfahre, wann du git reset vs. git revert in diesemis Git reset and revert Tutorial verwenden solltest.

Fazit

git cherry-pick ist eine leistungsstarke Methode, um bestimmte Commits von einem Zweig auf einen anderen anzuwenden, ohne den gesamten Zweig zusammenzuführen. Egal, ob du einen Bugfix oder ein Feature-Update verschiebst oder nur selektiv Änderungen vornimmst, es hilft dir, deinen Git-Verlauf sauber und konzentriert zu halten.

In diesem Leitfaden habe ich beschrieben, wie man einzelne und mehrere Commits auswählt, Konflikte auflöst und Best Practices befolgt, um häufige Fallstricke zu vermeiden. Wenn du cherry-pick klug einsetzt, kannst du deinen Arbeitsablauf verbessern und gleichzeitig für Ordnung in deinem Repository sorgen.

Wenn du deine Git-Kenntnisse vertiefen möchtest, ist Foundations of Git ein guter Startpunkt. Du kannst dich auch mit der Einführung in die GitHub-Konzepte beschäftigen oder einen strukturierten Ansatz mit dem Lernpfad GitHub Foundations wählen.

Jetzt, wo du weißt, wie du wie ein Profi Kirschen pflücken kannst, kannst du es bei deinem nächsten Projekt ausprobieren!