Zusammenführen einen Zweig in den Master in Git

1. Voraussetzungen
2. Vorbereitung der Zusammenführung in Git
3. Merge einen Branch in einen master mit der Methode merge in Git
4. Verschmelzen Sie einen Zweig zu einem Master mit der rebase-Methode
5. Abschluss

Eine der mächtigsten Funktionen von git ist die Branch-Erstellung und der Zusammenführungsvorgang. Git ermöglicht es Benutzern, einen neuen Zweig zu erstellen und ihn in den Entwicklungscode einzufügen. Diese Funktion verbessert den Entwicklungsprozess-Workflow für mehrere Projekte, indem sie spezifischere, kleinere und detailliertere Aufgaben fördert.

In diesem Tutorial-Artikel besprechen wir verschiedene Ansätze, um den Git-Feature-Branch mit dem Master zusammenzuführen.

Der Hauptvorteil von git ist sein Verzweigungssystem. Auf diesen Zweigen beruht die ganze Magie von GIT! Der Master-Zweig trägt alle vorgenommenen Änderungen. Ziel ist es daher, die Änderungen nicht direkt auf diesem Zweig vorzunehmen, sondern auf anderen Zweigen vorzunehmen und nach diversen Tests in den Master-Zweig zu integrieren.

In unserem Tutorial nehmen wir der Einfachheit halber an, dass es zwei Zweige gibt, den master-Zweig und den Feature-Zweig, der als feature-1 bekannt ist. Der Hauptzweig ist der Master-Zweig, der Produktionscode enthält, und der zweite Zweig ist der Ort, an dem Änderungen ausgeführt oder neue Funktionen implementiert werden. Am Ende, wenn eine Funktion oder ein Fehler genehmigt wird, wird sie mit dem Master zusammengeführt.

Beginnen wir die Demonstration der Zusammenführung zweier Zweige mit einem realen Beispiel. Zum Starten benötigen wir Folgendes.

Voraussetzungen

Erstellen Sie ein Repository auf GitHub

Ein erstes Repository kann wie in Github eingeführt erstellt werden

Fügen Sie als nächstes zwei Dateien im Master-Zweig hinzu, indem Sie die Schaltfläche Datei hinzufügen auf der Repository-Seite verwenden. Die Namen der Dateien lauten wie folgt.

• file1.txt
• file2.txt

In diesem Beispiel wird der folgende Textinhalt zu file1.txt bzw. file 2.txt hinzugefügt.

$ cat file1.txt
This is dummy text line 1
This is dummy text line 2
$ cat file2.txt
This is dummy test in 2nd file

Repository klonen

Klonen Sie als Nächstes Ihr neu erstelltes Repository von GitHub auf Ihr System, um eine lokale Kopie des Codes zu erstellen. Die Klon-URL kann wie unten über die Schaltfläche Code abgerufen werden.

Verwenden Sie zum Klonen den folgenden Befehl.

$ git clone git@github.com:project/demorepo.git

Verwenden Sie nach dem erfolgreichen Klonen den folgenden Befehl, um den Inhalt der Master-Zweigdateien anzuzeigen und zu überprüfen:

$ cat file1.txt
This is dummy text line 1
This is dummy text line 2
$ cat file2.txt
This is dummy test in 2nd file

Feature-Zweig erstellen

$ git branch feature-1

Dieser Befehl erstellt einen neuen Branch und keinen neuen Commit auf git.

Checkout-Funktionszweig

Zuvor haben wir mit git branch feature-1 einen neuen Branch erstellt. Der aktive Zweig ist jedoch der master-Zweig. Um die neue Verzweigung zu aktivieren, verwenden Sie diesen Befehl im Terminal:

$ git checkout feature-1
Switched to branch 'feature-1'

Der obige Befehl schaltet den aktiven Zweig von master auf feature-1 um. Nun ist dieser Zweig bereit für die individuelle Entwicklung.

Dateien im Feature-Branch ändern

Wir werden einige Commits hinzufügen oder neue Zeilen im Zweig feature-1 hinzufügen. In diesem Fall wird file2.txt lokal modifiziert und später wieder in den Master-Zweig eingebunden.

Für die bisherigen Änderungen sieht unser Commit-Diagramm wie folgt aus. Sowohl A als auch E repräsentieren die Zweigzustände master und feature-1. Derzeit sind Commit A und E identisch, da beim Checkout keine Dateien geändert werden.

A  ← master
   \
     E  ← feature-1

Nun wird file1.txt mit neuem Text aktualisiert. Verwenden Sie diesen Befehl, um den Inhalt zu aktualisieren.

$ echo "file update in feature branch" > file1.txt

file2.txt hat nun folgenden Inhalt.

$ cat file2.txt
This is dummy test in 2nd file

Der Unterschied zwischen altem und neuem Inhalt in file1.txt kann mit dem folgenden Befehl überprüft werden.

$ git diff
diff --git a/file1.txt b/file1.txt
index 11d66d4..48c9378 100644
--- a/file1.txt
+++ b/file1.txt
@@ -1,2 +1 @@
-This is dummy text line 1
-This is dummy text line 2
+file update in feature branch

Stellen Sie nun diese Datei bereit und erstellen Sie über den folgenden Befehl einen lokalen Commit.

$ git add file1.txt
$ git commit -am "update file via feature-1"
[feature-1 22b60b8] update file via feature-1
 1 file changed, 1 insertion(+), 2 d

Ein aktueller Snapshot des Commit-Baums sieht wie folgt aus. Hier ist F ein neues Commit, das im vorherigen Schritt erstellt wurde.

A  ← master
  \
    E --- F ← feature-1

Um ein reales Beispiel zu demonstrieren, wird der entfernte master auch gleichzeitig von anderen Entwicklern geändert, und diese Änderungen werden als Commit C und Commit D an den Master gepusht.

A --- B --- C --- D ← master
   \
      E --- F ← feature-1

Unten ist der aktualisierte Inhalt von file1.txt im Github-Repository im Master-Zweig. Hinweiszeile 2 wird aktualisiert und die Zeilen 3 und 4 werden neu erstellt.

Dies kann auch lokal validiert werden, indem Sie Ihren Verzweigungsverlauf in der Befehlsshell in Echtzeit mit dem folgenden Befehl visualisieren.

$ git fetch
$ git log --all --decorate --oneline --graph

Vorbereitung der Zusammenführung in Git

Mit Git haben wir zwei Möglichkeiten, unsere Feature-Branch-Änderungen mit dem entfernten master-Zweig zusammenzuführen:

1. Die merge-Methode
   Git merge ist ein Befehl, der Änderungen an einen anderen Branch überträgt. Es ermöglicht Entwicklern, ihre unabhängigen Codezeilen aus dem Feature-Branch zu nehmen und sie über das Git-Merge-Tool in einen einzigen Branch auf dem Master zu integrieren.

2. Die rebase-Methode
   Git rebase ist ein weiterer Befehl, der im Wesentlichen für den gleichen Zweck verwendet wird, außer dass er es ganz anders macht.

Lassen Sie uns beide Wege im Detail verstehen:

Merge einen Branch in einen master mit der Methode merge in Git

Das merge zielt darauf ab, feature- und master-Branches zu dem Commit zu konsolidieren, das den Inhalt aller beteiligten Branches beibehält. Git erreicht dies mit einem sogenannten Merge Commit. Das bedeutet auch, dass merge mehrere Zweige manipuliert.

Wenn die Zweige auseinandergegangen sind, d. h. einer ist kein Vorfahre des anderen. Git kann die Zusammenführung erreichen, indem es einen neuen zusätzlichen Commit mit mehreren Eltern macht. In der folgenden Abbildung: Wenn Sie einen Commit D und einen Commit F in verschiedenen Branches haben und die Branches mischen (über git merge), ist das Ergebnis ein Commit G dessen Eltern B und E sind.

A --- B --- C --- D ---	
  \				         \  
    \					  G  ← master
      E --- F --------- /	

Im obigen Diagramm ist G ein neu erstellter Commit und vollständig von git erstellt. Dieses Commit hat zwei Eltern! und sie haben einen Auftrag:

• Der erste Elternteil ist D, der zuvor master war.
• Der zweite Elternteil ist F, was vorher feature-1 war.

Diese Art von Commit wird als Merge-Commit bezeichnet.

Wechseln Sie nun zurück zu unserem Repository-Beispiel und fügen Sie den neu erstellten feature-1-Zweig zu master zusammen.

Schauen Sie sich zuerst den master-Zweig an.

$ git checkout master

Ziehen Sie nun die Remote-Master-Änderungen auf den lokalen master.

$ git pull origin master

From github.com:repo/demorepo

 * branch            master     -> FETCH_HEAD
   Updating 17cc6b4..a802b6b
   Fast-forward
    file1.txt | 5 ++++-
    1 file changed, 4 insertions(+), 1 deletion(-)

Verwenden Sie anschließend den folgenden Befehl, um den Feature-Zweig, d. h. feature-1, mit dem derzeit aktiven Zweig zusammenzuführen.

$ git merge feature-1

Der feature-1-Zweig wird vollständig mit dem master-Zweig zusammengeführt, wenn dieser Schritt erfolgreich abgeschlossen wurde. Wenn git diese Zusammenführungskonflikte jedoch nicht automatisch lösen kann, schlägt es mit einem Zusammenführungskonfliktfehler fehl.

Dies ist ein sehr typisches Szenario; Dies kann passieren, wenn zwei Branches denselben Teil der Datei ändern und Git nicht auflösen kann, welcher Teil verwendet werden soll. Genau das passiert in unserem Beispiel. Dieser Fall wird unten über git gezeigt.

Auto-merging file1.txt
CONFLICT (content): Merge conflict in file1.txt
Automatic merge failed; fix conflicts and then commit the result.

Immer wenn Git auf einen Konflikt stößt, fügt es <<<<<<< & ======= hinzu, um den Abschnitt hervorzuheben, der den Konflikt verursacht hat und dieser manuell gelöst werden muss.

Sobald entschieden ist, welcher Teil in der endgültigen Masterversion der Datei beibehalten werden soll, muss eine Person den irrelevanten Code (einschließlich Konfliktindikatoren) entfernen. Übertragen Sie die Änderungen schließlich wie unten beschrieben in den Remote-Zweig.

$ git add .
$ git commit -am "resolving the mergeconflict"
[master 1acce69] resolving the mergeconflict
$ git push

Auf diese Weise wird der Zweig feature-1 erfolgreich mit dem entfernten master zusammengeführt.

Als Nächstes überprüfen wir den Verzweigungsverlauf erneut mit dem folgenden Befehl.

git log --all --decorate --oneline --graph

Wir können überprüfen, ob git merge einen Merge Commit mit der Commit-ID 1acce69 erstellt hat, um den feature-1-Zweig mit origin/master zusammenzuführen.

Verschmelzen Sie einen Zweig zu einem Master mit der rebase-Methode

Betrachten Sie noch einmal die Situation, in der unsere Feature- und Master-Zweigs nicht synchron sind und zusammengeführt werden müssen. Erinnern wir uns auch an die Abbildung, die diese Situation zuvor zeigt.

A --- B --- C --- D ← master
   \
      E --- F ← feature-1

Als alternative Möglichkeit zum Zusammenführen können Sie den Zweig feature-1 in den Zweig master mit Rebase-Option zusammenführen. Die rebase vereinheitlicht die beteiligten Branches, indem Commits aus dem Feature-Zweig einfach vor den Master-Zweig gestellt werden.

Dies wird über die folgenden Befehle erreicht,

git checkout master
git pull
git checkout feature-1
git rebase master

Wir können die Abbildung wie unten sehen, nachdem wir rebase ausgeführt haben.

A --- B --- C --- D----(operation rebase)----- E--------F   ← master

Aus der obigen Abbildung ist ersichtlich, dass etwas Schönes, das rebase tut, darin besteht, einen linearen, saubereren und einfacher zu lesenden Commit-Verlauf zu erzeugen. Durch das Zusammenführen wird auch nicht dieses zusätzliche seltsame merge commit generiert.

Der Nachteil dieses Ansatzes besteht darin, dass Rebase die gesamte Struktur der beteiligten Branches ändert, einschließlich des Umschreibens der Commit-Historie dieser Branches. Da rebase keinen Merge-Commit erzeugt, kann man nicht nachvollziehen, wann zwei Branches zusammengeführt wurden, da rebase am Ende des Prozesses einen linearen Branch generiert.

Abschluss

Beide Befehle sind sehr nützlich; in verschiedenen Situationen hat jede Seite jedoch die folgenden Vorteile.

Git rebase

• Optimieren Sie eine komplexe Geschichte.
• Vermeiden Sie das Zusammenführen von Commit-Rauschen in Repositorys mit beschäftigten Branches.
• Riskant, wenn es nicht richtig verwendet wird, da es die Geschichte nicht speichert.

Git merge

• Einfach zu benutzen.
• Da jedes Mal ein zusätzlicher Merge-Commit erstellt wird, sieht der Commit-Verlauf verwirrend und schmutzig aus.
• Bewahrt die vollständige Geschichte und chronologische Reihenfolge.