Git-Lernen: Den Git-Merge-Befehl verstehen

In diesem Artikel lernen Sie Git-Branches kennen und stellen die Git-Merge-Befehle für die Verwendung von Branches vor. Ich hoffe, er wird Ihnen hilfreich sein!

In Git ist Merge eine Möglichkeit, den geforkten Commit-Verlauf wieder zusammenzusetzen. Mit dem Befehl git merge können Sie den Zweig, den Sie zuvor mit dem Befehl git branch erstellt haben, und die unabhängig auf diesem Zweig entwickelten Inhalte in einen Zweig integrieren. git merge命令用来将你之前使用git branch命令创建的分支以及在此分支上独立开发的内容整合为一个分支。

请注意下面的所有命令都会是将其他分支合并到当前所在工作分支上。当前工作分支的内容会由于merge操作产生更新，但是目标分支则完全不受影响。再次强调，这意味着git merge通常与其他几个git命令一起使用，包括使用git checkout命令来选择当前工作分支，以及使用git branch -d命令来删除已经合并过的废弃分支。

它是如何运行的

git merge会将多个提交序列合并进一个统一的提交历史。在最常见的使用场景中，git merge被用来合并两个分支。在本文档接下来的部分，我们会专注于这种合并场景。在这种场景中，git merge接受两个commit指针，通常是两个分支的顶部commit，然后向前追溯到这两个分支最近的一个共同提交。一旦找到这个共同提交，Git就会创建一个新的"merge commit"，用来合并两个分支上各自的提交序列。

比如说我们有一个功能分支由main分支派生出来，现在我们希望将这个功能分支合并回main分支。

执行合并命令会将指定分支合并到当前工作分支上，我们假设当前工作分支为main。Git根据两个分支自行决定合并提交的算法（将在下面具体讨论）。

合并commit与普通commit不一样，因为合并commit会有两个父提交。创建一个合并commit时Git会尝试自动将两个独立的提交历史合并为一个。不过当Git发现某一块数据在两边的提交历史中都含有变更，它将无法自动对其进行合并。这种情况被称为版本冲突，此时Git需要人为介入调整才能继续进行合并。

准备合并

在实际进行合并操作之前，需要进行一些准备步骤，以保证合并过程能够顺利进行。

确认接收合并的分支

执行git status命令查看当前分支的状态，确保HEAD指正指向的是正确的接收合并的分支。如果不是，执行git checkout命令切换到正确的分支。在我们的示例中，执行git checkout main。

获取最新的远程提交

确保合并操作涉及的两个分支都更新到远程仓库的最新状态。执行git fetch拉取远程仓库的最新提交。一旦fetch操作完成，为了保证main分支与远程分支同步，还需执行git pull命令。

合并

当上面提及的准备工作都已完备，合并就可以正式开始了。执行git merge <branch></branch>命令，其中为需要合并到当前分支的目标分支名称。

快进合并

当前工作分支到合并目标分支之间的提交历史是线性路径时，可以进行快进合并。在这种情况下，不需要真实的合并两个分支，Git只需要把当前分支的顶端指针移动到目标分支的顶端就可以了（也就是快进的意思）。在这种情况下快进合并成功的将提交历史合并至一处，毕竟目标分支中的提交此时都包含在当前分支的提交历史中了。对于将功能分支快进合并到main

Bitte beachten Sie, dass alle folgenden Befehle andere Zweige in den aktuellen Arbeitszweig einbinden. Der Inhalt des aktuellen Arbeitszweigs wird durch den Zusammenführungsvorgang aktualisiert, der Zielzweig ist jedoch überhaupt nicht betroffen. Dies bedeutet wiederum, dass git merge normalerweise in Verbindung mit mehreren anderen Git-Befehlen verwendet wird, einschließlich der Verwendung des Befehls git checkout zum Auswählen des aktuellen Arbeitszweigs und von git branch -d Befehl zum Löschen zusammengeführter verlassener Zweige.

So funktioniert es

git merge führt mehrere Commit-Sequenzen zu einem einheitlichen Commit-Verlauf zusammen. Im häufigsten Anwendungsszenario wird git merge verwendet, um zwei Zweige zusammenzuführen. Im weiteren Verlauf dieses Dokuments konzentrieren wir uns auf dieses Zusammenführungsszenario. In diesem Szenario akzeptiert git merge zwei Commit-Zeiger, normalerweise den obersten Commit der beiden Zweige, und führt dann eine Rückverfolgung zum letzten gemeinsamen Commit der beiden Zweige durch. Sobald dieser gemeinsame Commit gefunden ist, erstellt Git einen neuen „Merge-Commit“, der die jeweiligen Commit-Sequenzen in beiden Zweigen zusammenführt.

Zum Beispiel haben wir einen Feature-Zweig, der vom main-Zweig abgeleitet ist, und nun wollen wir diesen Feature-Zweig wieder mit dem main-Zweig zusammenführen.

Ausführen Der Merge-Befehl führt den angegebenen Zweig mit dem aktuellen Arbeitszweig zusammen. Wir gehen davon aus, dass der aktuelle Arbeitszweig main ist. Git bestimmt seinen eigenen Algorithmus zum Zusammenführen von Commits basierend auf den beiden Zweigen (im Detail weiter unten besprochen). 🎜🎜🎜🎜Zusammenführen Commit unterscheidet sich vom gewöhnlichen Commit, da Merge-Commit zwei übergeordnete Commits hat. Wenn Sie einen Merge-Commit erstellen, versucht Git, zwei separate Commit-Verläufe automatisch zu einem zusammenzuführen. Wenn Git jedoch feststellt, dass ein bestimmtes Datenelement Änderungen im Übermittlungsverlauf beider Seiten enthält, kann es diese nicht automatisch zusammenführen. Diese Situation wird als Versionskonflikt bezeichnet. Zu diesem Zeitpunkt erfordert Git einen manuellen Eingriff, um die Zusammenführung fortzusetzen. 🎜

Zusammenführung vorbereiten

🎜Vor dem eigentlichen Zusammenführungsvorgang müssen einige Vorbereitungsschritte durchgeführt werden, um sicherzustellen, dass der Zusammenführungsprozess reibungslos ablaufen kann. 🎜

Bestätigen Sie den Empfang des zusammengeführten Zweigs

🎜Führen Sie den Befehl git status aus, um den Status des aktuellen Zweigs zu überprüfen, und stellen Sie sicher, dass HEAD nimmt Korrekturen vor. Zeigt auf den richtigen Zweig, um die Zusammenführung zu empfangen. Wenn nicht, führen Sie den Befehl git checkout aus, um zum richtigen Zweig zu wechseln. Führen Sie in unserem Beispiel git checkout main aus. 🎜

Holen Sie sich das neueste Remote-Commit

🎜Stellen Sie sicher, dass beide am Zusammenführungsvorgang beteiligten Zweige auf den neuesten Status des Remote-Repositorys aktualisiert werden. Führen Sie git fetch aus, um den neuesten Commit aus dem Remote-Warehouse abzurufen. Sobald der Abrufvorgang abgeschlossen ist, muss der Befehl git pull ausgeführt werden, um sicherzustellen, dass der main-Zweig mit dem Remote-Zweig synchronisiert ist. 🎜

Zusammenschluss

🎜Wenn die oben genannten Vorbereitungen abgeschlossen sind, kann der Zusammenschluss offiziell beginnen. Führen Sie den Befehl git merge <branch></branch> aus. Dabei steht der Name des Zielzweigs, der mit dem aktuellen Zweig zusammengeführt werden muss. 🎜

Fast-Forward-Merge

🎜Fast-Forward-Merge kann durchgeführt werden, wenn der Übermittlungsverlauf zwischen dem aktuellen Arbeitszweig und dem Zusammenführungszielzweig ein linearer Pfad ist. In diesem Fall ist es nicht erforderlich, die beiden Zweige tatsächlich zusammenzuführen. Git muss lediglich den oberen Zeiger des aktuellen Zweigs an den Anfang des Zielzweigs verschieben (d. h. einen schnellen Vorlauf durchführen). In diesem Fall führt die schnelle Zusammenführung den Commit-Verlauf erfolgreich an einer Stelle zusammen. Schließlich sind die Commits im Zielzweig nun im Commit-Verlauf des aktuellen Zweigs enthalten. Informationen zum schnellen Zusammenführen des Feature-Zweigs in den main-Zweig finden Sie in der folgenden Abbildung: 🎜🎜🎜🎜🎜Allerdings ist ein schnelles Zusammenführen nicht zulässig, wenn sich die beiden Zweige gegabelt haben . . Wenn der Festschreibungsverlauf des Zielzweigs relativ zum aktuellen Zweig nicht linear ist, kann Git nur mithilfe des Drei-Wege-Zusammenführungsalgorithmus entscheiden, wie die beiden Zweige zusammengeführt werden. Der Drei-Wege-Merge-Algorithmus erfordert die Verwendung eines dedizierten Commits, um die Commit-Verläufe beider Seiten zu integrieren. Dieser Begriff ergibt sich aus der Tatsache, dass Git drei Commits verwenden muss, um einen Merge-Commit zu generieren: den obersten Commit der beiden Zweige und den gemeinsamen Vorgänger-Commit. 🎜🎜🎜🎜

Obwohl es tatsächlich Optionen gibt, diese verschiedenen Zusammenführungsstrategien zu verwenden, bevorzugen die meisten Entwickler die schnelle Zusammenführung (durch Verwendung des Befehls rebasing ), insbesondere für die Entwicklung kleiner Funktionen oder Fehlerbehebungen für die Zusammenführung langfristiger Entwicklungszweige. Es ist wahrscheinlicher, dass die Drei-Wege-Zusammenführung verwendet wird. Im zweiten Szenario wird der durch die Zusammenführung generierte Zusammenführungs-Commit im Commit-Verlauf als Zeichen für die Zusammenführung der beiden Zweige gespeichert.

Als nächstes verwenden wir das erste Beispiel unten, um zu zeigen, wie man eine schnelle Vorwärtszusammenführung durchführt. Der folgende Befehl erstellt zunächst einen neuen Zweig, führt zwei Commits für den neuen Zweig durch und verwendet dann die schnelle Zusammenführung, um den neuen Zweig wieder mit dem Zweig main zusammenzuführen. main分支。

# Start a new feature
git checkout -b new-feature main
# Edit some files
git add <file>
git commit -m "Start a feature"
# Edit some files
git add <file>
git commit -m "Finish a feature"
# Merge in the new-feature branch
git checkout main
git merge new-feature
git branch -d new-feature

这个例子中的工作流程通常用于短期功能的开发，这种开发流程更多地被当做是比较独立的一次开发流程，与之对应的则是需要协调和管理的长期功能开发分支。

另外还需注意到，在此例中Git不会对git branch -d命令发出警告，因为new-feature的内容已经合并到主分支里了。

在某些情况下，虽然目标分支的提交历史相对于当前分支是线性的，可以进行快进合并，但你仍然希望有一个合并commit来标志合并在此commit发生过，那么可以在执行git merge命令时使用--no-ff选项。

git merge --no-ff <branch>

以上命令将指定分支合并到当前分支，但总会生成一个合并commit（即便这一合并操作可以快进）。当你需要在仓库的提交历史中标记合并事件时这一命令相当有用。

三路合并

接下来的例子与上面比较像，但是因为main分支在feature分支向前发展的过程中，自身也发生的改变，因此在合并时需要进行三路合并。在进行大的功能开发或者有多个开发者同时进行开发时这种场景相当常见。

Start a new feature
git checkout -b new-feature main
# Edit some files
git add <file>
git commit -m "Start a feature"
# Edit some files
git add <file>
git commit -m "Finish a feature"
# Develop the main branch
git checkout main
# Edit some files
git add <file>
git commit -m "Make some super-stable changes to main"
# Merge in the new-feature branch
git merge new-feature
git branch -d new-feature

需注意在这种情况下，由于没有办法直接把main的顶端指针移动到new-feature分支上，因此Git无法执行快进合并。

在大多数实际工作场景中，new-feature应该是一个很大的功能，开发过程持续了相当长的时间，这也就难免同时期在main分支上也有新的提交。如果你的功能分支大小像上面的例子一样小，则完全可以使用rebase将new-feature分支变基到main分支上，然后再执行一次快进合并。这样也会避免在项目提交历史中产生过多的冗余。

解决冲突

如果将要合并的两个分支都修改了同一个而文件的同一个部分内容，Git就无法确定应该使用哪个版本的内容。当这种情况发生时，合并过程会停止在合并commit提交之前，以便给用户留下机会手动修复这些冲突。

在Git的合并过程中，很棒的一点是它使用人们熟知的 编辑 / 暂存 / 提交 这样的工作流程来解决冲突。当碰到合并冲突时，执行git status命令会列出哪些文件含有冲突并需要手动解决。比如说当两个分支都修改了hello.py文件的同一部分，你会看到类似下面这样的信息：

On branch main
Unmerged paths:
(use "git add/rm ..." as appropriate to mark resolution)
both modified: hello.py

冲突是如何显示的

当Git在合并过程中碰到了冲突，它会编辑受影响的文件中的相关内容，并添加视觉标记用以展示冲突中双方在此部分的不同内容。这些视觉标记为：>>>>>>。要找到冲突发生的具体位置，在文件中搜索这些视觉标记会非常便捷地达成目的。

here is some content not affected by the conflict
<<<<<<< main
this is conflicted text from main
=======
this is conflicted text from feature branch
>>>>>>> feature branch;

通常来说在 ====== 标记之前的内容来自于接收合并的分支，而在这之后的内容来自于要合并的分支。

一旦找到冲突的部分，就可以根据需要来修正冲突。当你完成了冲突的修复并准备好继续进行合并，只需要执行git add命令把已经解决好冲突的文件添加暂存区，告诉Git这些冲突已经解决完毕即可。这之后就像正常提交代码一样执行git commitrrreee

Der Workflow in diesem Beispiel wird normalerweise für die kurzfristige Feature-Entwicklung verwendet. Dieser Entwicklungsprozess wird eher als relativ unabhängiger Entwicklungsprozess betrachtet und entspricht langfristigen Feature-Entwicklungszweigen, die Koordination und Verwaltung erfordern.

Beachten Sie außerdem, dass Git in diesem Beispiel keine Warnung für den Befehl git branch -d ausgibt, da der Inhalt von new-feature in den Hauptzweig eingefügt wurde. 🎜🎜Obwohl der Commit-Verlauf des Zielzweigs relativ zum aktuellen Zweig linear ist, kann in einigen Fällen eine schnelle Zusammenführung durchgeführt werden. Sie möchten jedoch dennoch einen Zusammenführungs-Commit haben, um zu markieren, dass die Zusammenführung bei diesem Commit stattgefunden hat. Dann können Sie --no-ff ausführen, wenn Sie den Befehl code>git merge verwenden. 🎜rrreee🎜Der obige Befehl führt den angegebenen Zweig mit dem aktuellen Zweig zusammen, generiert jedoch immer einen Zusammenführungs-Commit (auch wenn dieser Zusammenführungsvorgang schnell vorgespult werden kann). Dieser Befehl ist nützlich, wenn Sie Zusammenführungsereignisse im Commit-Verlauf des Repositorys markieren müssen. 🎜

Drei-Wege-Zusammenführung

🎜Das nächste Beispiel ähnelt dem oben, jedoch befindet sich der Zweig main im Prozess der Funktion Der Zweig selbst hat sich ebenfalls geändert, sodass während der Zusammenführung eine Drei-Wege-Zusammenführung erforderlich ist. Dieses Szenario kommt recht häufig vor, wenn umfangreiche Feature-Entwicklungen durchgeführt werden oder wenn mehrere Entwickler gleichzeitig entwickeln. 🎜rrreee🎜Da es in diesem Fall keine Möglichkeit gibt, den obersten Zeiger von main direkt auf den Zweig new-feature zu verschieben, muss Git Folgendes tun: Schnellvorlauf-Zusammenführung. 🎜🎜In den meisten tatsächlichen Arbeitsszenarien sollte new-feature eine sehr große Funktion sein und der Entwicklungsprozess dauert lange, sodass es unvermeidlich ist, dass main dies sein wird Gleichzeitig wurden auch neue Commits im Code-Zweig entwickelt. Wenn die Größe Ihres Feature-Zweigs so klein ist wie im obigen Beispiel, können Sie rebase verwenden, um den new-feature-Zweig auf den main-Zweig umzubasieren und dann einen schnellen Vorlauf durchzuführen wieder zusammenführen. Dadurch wird auch vermieden, dass im Commit-Verlauf des Projekts zu viel Redundanz entsteht. 🎜

Konflikte lösen

🎜Wenn die beiden zusammenzuführenden Zweige denselben Teil der Datei geändert haben, kann Git nicht bestimmen, welche Version des Inhalts verwendet werden soll. In diesem Fall wird der Zusammenführungsprozess gestoppt, bevor der Zusammenführungs-Commit festgeschrieben wird, um dem Benutzer die Möglichkeit zu geben, diese Konflikte manuell zu beheben. 🎜🎜Das Tolle am Merge-Prozess von Git ist, dass er den bekannten Bearbeitungs-/Stufen-/Commit-Workflow verwendet, um Konflikte zu lösen. Wenn ein Zusammenführungskonflikt auftritt, wird durch Ausführen des Befehls git status aufgelistet, welche Dateien Konflikte enthalten und manuell gelöst werden müssen. Wenn beispielsweise beide Zweige denselben Teil der Datei hello.py ändern, wird eine Meldung ähnlich der folgenden angezeigt: 🎜rrreee

Der Konflikt ist So wird angezeigt

🎜Wenn Git während des Zusammenführungsprozesses auf einen Konflikt stößt, bearbeitet es den relevanten Inhalt in der betroffenen Datei und fügt visuelle Markierungen hinzu, um den unterschiedlichen Inhalt der Konfliktparteien in diesem Teil anzuzeigen. Diese visuellen Markierungen sind: >>>>>>. Um den spezifischen Ort zu finden, an dem ein Konflikt auftritt, können Sie einfach nach diesen visuellen Markierungen in der Datei suchen. 🎜rrreee🎜 Im Allgemeinen stammt der Inhalt vor der Markierung ====== von dem Zweig, der die Zusammenführung erhält, und der Inhalt danach kommt von dem Zweig, der zusammengeführt werden soll. 🎜🎜Sobald Sie den widersprüchlichen Teil gefunden haben, können Sie den Konflikt nach Bedarf korrigieren. Wenn Sie die Konflikte behoben haben und bereit sind, mit der Zusammenführung fortzufahren, müssen Sie nur noch den Befehl git add ausführen, um die Dateien mit gelösten Konflikten zum Staging-Bereich hinzuzufügen und Git mitzuteilen, dass diese Konflikte gelöst wurden . Führen Sie anschließend git commit aus, genau wie bei der normalen Übermittlung des Codes, um den Merge-Commit abzuschließen. Dieser Vorgang ist genau derselbe wie das Senden von Code unter normalen Umständen, was bedeutet, dass der Umgang mit Konflikten für normale Entwickler ein Kinderspiel ist. 🎜🎜 Beachten Sie außerdem, dass Zusammenführungskonflikte nur während einer Drei-Wege-Zusammenführung auftreten können und nicht während einer Schnellvorlauf-Zusammenführung auftreten. 🎜

Zusammenfassung

Dieser Artikel ist eine Übersicht über git mergeBefehle. Bei der Verwendung von Git ist das Zusammenführen ein sehr wichtiger Vorgang. In diesem Artikel werden die Mechanismen hinter Zusammenführungsvorgängen und die Unterschiede zwischen Schnellvorlauf-Zusammenführungen und Drei-Wege-Zusammenführungen erläutert. Die wichtigsten Punkte, die sich die Leser merken müssen, sind folgende:

• Der Git-Merge-Prozess besteht darin, verschiedene Commit-Sequenzen in einem einheitlichen Commit-Verlauf zusammenzuführen.

• Der Git-Merge-Prozess verfügt über zwei Hauptmethoden: Fast-Forward-Merge und Drei-Wege-Zusammenführung

• Sofern es keinen Konflikt in den beiden Commit-Sequenzen gibt, kann Git die Commits normalerweise automatisch zusammenführen

Empfohlenes Lernen: „Git-Tutorial“

Das obige ist der detaillierte Inhalt vonGit-Lernen: Den Git-Merge-Befehl verstehen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!