Was ist der beste (und sicherste) Weg, um einen Git-Zweig mit dem Master zusammenzuführen?

Ein neuer Zweig von masterwird erstellt, wir nennen es test.

Es gibt mehrere Entwickler, die sich entweder zu masteranderen Zweigen verpflichten oder diese erstellen und später zusammenführen master.

Nehmen wir an, die Arbeit testdauert mehrere Tage und Sie möchten ständig über die darin enthaltenen testCommits informiert werden master.

Ich tun würde , git pull origin masteraus test.

Frage 1: Ist das der richtige Ansatz? Andere Entwickler hätten leicht an denselben Dateien arbeiten können wie ich übrigens.

Meine Arbeit testist erledigt und ich bin bereit, sie wieder zusammenzuführen master. Hier sind die zwei Möglichkeiten, die ich mir vorstellen kann:

EIN:

git checkout test
git pull origin master
git push origin test
git checkout master
git pull origin test 

B:

git checkout test
git pull origin master
git checkout master
git merge test

Ich verwende es nicht, --rebaseda Rebase nach meinem Verständnis die Änderungen abruft masterund meine darüber stapelt, sodass Änderungen, die von anderen Personen vorgenommen wurden, überschrieben werden können.

Frage 2: Welche dieser beiden Methoden ist richtig? Was ist der Unterschied dort?

Das Ziel bei all dem ist es, meinen testZweig über die Ereignisse masterauf dem masterLaufenden zu halten, und später könnte ich sie wieder zusammenführen , um die Zeitachse so linear wie möglich zu halten.

Wie würde ich das machen?

git checkout master
git pull origin master
git merge test
git push origin master

Wenn ich einen lokalen Zweig von einem entfernten Zweig habe, kann ich andere Zweige als diesen nicht mit dem entfernten zusammenführen. Außerdem würde ich meine Änderungen nicht pushen, bis ich mit dem, was ich pushen möchte, zufrieden bin und ich würde überhaupt keine Dinge pushen, die nur für mich und mein lokales Repository sind. In Ihrer Beschreibung scheint das testnur für Sie zu sein? Also kein Grund, es zu veröffentlichen.

git versucht immer, deine und andere Veränderungen zu respektieren, und das wird auch so sein --rebase. Ich glaube nicht, dass ich es angemessen erklären kann, also schauen Sie sich das Git-Buch an - Rebasing oder git-ready: Einführung in die Neugründung für eine kleine Beschreibung. Es ist eine ziemlich coole Funktion

Dies ist eine sehr praktische Frage, aber alle obigen Antworten sind nicht praktisch.

Mögen

git checkout master
git pull origin master
git merge test
git push origin master

Dieser Ansatz hat zwei Probleme :

1. Es ist unsicher, da wir nicht wissen, ob es Konflikte zwischen Testzweig und Hauptzweig gibt.

2. Es würde alle Test-Commits zu einem Merge-Commit für den Master "zusammenpressen". Das heißt, auf dem Hauptzweig können nicht alle Änderungsprotokolle des Testzweigs angezeigt werden.

Wenn wir also vermuten, dass es zu Konflikten kommen könnte, können wir folgende Git-Operationen durchführen:

git checkout test
git pull 
git checkout master
git pull
git merge --no-ff --no-commit test

Testen Sie mergevorher commit, vermeiden Sie ein schnelles Festschreiben durch --no-ff,

Wenn ein Konflikt auftritt, können wir git statusDetails zu den Konflikten überprüfen und versuchen, sie zu lösen

git status

Sobald wir die Konflikte gelöst haben oder wenn es keinen Konflikt gibt, sind wir commitund pushsie

git commit -m 'merge test branch'
git push

Auf diese Weise geht jedoch der im Testzweig protokollierte Änderungsverlauf verloren, und es würde für andere Entwickler schwierig sein, den Verlauf des Projekts zu verstehen.

Die beste Methode ist also, dass wir rebasestatt verwenden müssen merge(nehmen wir an, wenn wir in dieser Zeit die Verzweigungskonflikte gelöst haben).

Im Folgenden finden Sie ein einfaches Beispiel für erweiterte Vorgänge unter http://git-scm.com/book/en/v2/Git-Branching-Rebasing

git checkout master
git pull
git checkout test
git pull
git rebase -i master
git checkout master
git merge test

Ja, wenn Sie das Obermaterial fertig haben, werden alle Commits des Testzweigs auf den Kopf des Hauptzweigs verschoben. Der Hauptvorteil der Neubasierung besteht darin, dass Sie eine lineare und viel sauberere Projekthistorie erhalten.

Das einzige, was Sie vermeiden müssen, ist: Verwenden Sie es niemals rebasein öffentlichen Zweigen wie dem Hauptzweig.

Führen Sie niemals Operationen wie die folgenden aus:

git checkout master
git rebase -i test

Details zu https://www.atlassian.com/git/tutorials/merging-vs-rebasing/the-golden-rule-of-rebasing

Blinddarm:

• Wenn Sie sich bei der Neubasierung nicht sicher sind, lesen Sie bitte: https://git-scm.com/book/en/v2/Git-Branching-Rebasing

Weder eine Neueinstellung noch eine Zusammenführung sollten Änderungen überschreiben (es sei denn, Sie entscheiden sich bei der Lösung eines Konflikts dafür).

Der übliche Ansatz bei der Entwicklung ist

git checkout master
git pull
git checkout test
git log master.. # if you're curious
git merge origin/test # to update your local test from the fetch in the pull earlier

Wenn Sie bereit sind, wieder zum Master zu wechseln,

git checkout master
git log ..test # if you're curious
git merge test
git push

Wenn Sie sich Sorgen machen, etwas bei der Zusammenführung zu brechen, git merge --abortist es für Sie da.

Push und dann Pull als Mittel zum Zusammenführen zu verwenden, ist dumm. Ich bin mir auch nicht sicher, warum Sie den Test zum Ursprung bringen.

Ich würde zuerst den zu verschmelzenden Zweig so sauber wie möglich machen. Führen Sie Ihre Tests aus und stellen Sie sicher, dass der Status Ihren Wünschen entspricht. Bereinigen Sie die neuen Commits mit Git Squash .

Neben der Antwort von KingCrunches empfehle ich die Verwendung

git checkout master
git pull origin master
git merge --squash test
git commit
git push origin master

Möglicherweise haben Sie in der anderen Verzweigung viele Festschreibungen vorgenommen. Dies sollte nur eine Festschreibung in der Hauptverzweigung sein. Um den Commit-Verlauf so sauber wie möglich zu halten, möchten Sie möglicherweise alle Ihre Commits aus dem Testzweig in einem Commit im Master-Zweig zusammenfassen (siehe auch: Git: Squash oder nicht Squash? ). Dann können Sie die Commit-Nachricht auch in etwas sehr Ausdrucksstarkes umschreiben. Etwas, das leicht zu lesen und zu verstehen ist, ohne sich in den Code zu vertiefen.

edit: Das könnte dich interessieren

• Was ist in git der Unterschied zwischen Merge - Quash und Rebase?
• Zusammenführen vs. Wiederherstellen
• So erstellen Sie eine Pull-Anforderung neu

Auf GitHub mache ich am Ende Folgendes für einen Feature-Zweig mybranch:

Holen Sie sich das Neueste vom Ursprung

$ git checkout master
$ git pull origin master

Suchen Sie den Merge-Basis-Hash:

$ git merge-base mybranch master
c193ea5e11f5699ae1f58b5b7029d1097395196f

$ git checkout mybranch
$ git rebase -i c193ea5e11f5699ae1f58b5b7029d1097395196f

Stellen Sie jetzt sicher, dass nur der erste ist pick, der Rest ist s:

pick 00f1e76 Add first draft of the Pflichtenheft
s d1c84b6 Update to two class problem
s 7486cd8 Explain steps better

Als nächstes wählen Sie eine sehr gute Commit-Nachricht und drücken Sie auf GitHub. Stellen Sie dann die Pull-Anfrage.

Nach dem Zusammenführen der Pull-Anforderung können Sie sie lokal löschen:

$ git branch -d mybranch

und auf GitHub

$ git push origin :mybranch

Alter Thread, aber ich habe meinen Weg nicht gefunden . Dies kann für jemanden von Nutzen sein, der mit Rebase arbeitet und alle Commits aus einem (Feature-) Zweig über Master zusammenführen möchte. Wenn unterwegs ein Konflikt vorliegt, können Sie diesen für jedes Commit lösen. Sie behalten während des Vorgangs die volle Kontrolle und können jederzeit abbrechen.

Holen Sie sich Master und Branch auf den neuesten Stand:

git checkout master
git pull --rebase origin master
git checkout <branch_name>
git pull --rebase origin <branch_name>

Zweig über Master zusammenführen:

git checkout <branch_name>
git rebase master

Optional: Wenn Sie während der Rebase auf Konflikte stoßen:

Lösen Sie zunächst den Konflikt in der Datei. Dann:

git add .
git rebase --continue

Schieben Sie Ihren neu basierten Zweig:

git push origin <branch_name>

Jetzt haben Sie zwei Möglichkeiten:

• A) Erstellen Sie einen PR (zB auf GitHub) und führen Sie ihn dort über die Benutzeroberfläche zusammen
• B) Gehen Sie zurück in die Befehlszeile und führen Sie den Zweig zum Master zusammen

git checkout master
git merge --no-ff <branch_name>
git push origin master

Erledigt.

Dies ist der Workflow, den ich bei meiner Arbeit mit dem Team verwende. Das Szenario ist wie von Ihnen beschrieben. Erstens, wenn ich mit der Arbeit fertig testbin, stelle ich die Basis mit dem Master wieder her, um alles einzuziehen, was während der Zeit, in der ich an der testVerzweigung gearbeitet habe, dem Master hinzugefügt wurde .

git pull -r upstream master

Dadurch werden die Änderungen an Master übertragen, seit Sie die gegabelt haben test Zweig und angewendet haben. Anschließend werden die Änderungen angewendet, die Sie vorgenommen haben, um "über" den aktuellen Status des Masters zu testen. Hier kann es zu Konflikten kommen, wenn die anderen Personen Änderungen an denselben Dateien vorgenommen haben, die Sie im Test bearbeitet haben. Wenn dies der Fall ist, müssen Sie diese manuell beheben und festschreiben. Sobald Sie dies getan haben, können Sie problemlos zum Hauptzweig wechseln und testproblemlos zusammenführen.

git checkout master
git pull origin master
# Merge branch test into master
git merge test

Wenn die Datei nach dem Zusammenführen geändert wird, wird beim Zusammenführen der Fehler "Konflikt lösen" angezeigt.

Dann müssen Sie zuerst alle Ihre Konflikte lösen, dann müssen Sie erneut alle Ihre Änderungen festschreiben und dann pushen

git push origin master

Dies ist besser, wenn Sie Änderungen im Testzweig vorgenommen haben, da er wusste, welche Änderungen er vorgenommen hat.

Ich würde die Rebase-Methode verwenden. Meistens, weil es Ihren Fall semantisch perfekt widerspiegelt, dh. Was Sie tun möchten, ist, den Status Ihres aktuellen Zweigs zu aktualisieren und so zu tun, als ob er auf dem neuesten basiert.

Also, ohne auch nur auszuchecken master, würde ich:

git fetch origin
git rebase -i origin/master
# ...solve possible conflicts here

Nur das Abrufen vom Ursprung aktualisiert natürlich nicht Ihren lokalen Status master(da keine Zusammenführung durchgeführt wird), aber es ist für unseren Zweck vollkommen in Ordnung - wir möchten das Umschalten vermeiden, um Zeit zu sparen.

Die Antwort von @ KingCrunch sollte in vielen Fällen funktionieren. Ein Problem, das auftreten kann, ist, dass Sie sich möglicherweise auf einem anderen Computer befinden, der das Neueste aus dem Test ziehen muss. Daher empfehle ich, zuerst den Test zu ziehen. Die Revision sieht folgendermaßen aus:

git checkout test
git pull
git checkout master
git pull origin master
git merge test
git push origin master

Sie müssen den Zweig zum Ziehen auschecken lassen, da das Ziehen das Zusammenführen mit dem Master bedeutet und Sie einen Arbeitsbaum zum Zusammenführen benötigen.

git checkout master
git pull

Keine Notwendigkeit, zuerst auszuchecken; rebase macht mit zwei Argumenten das Richtige

git rebase master test  

git checkout master
git merge test

git push schiebt standardmäßig alle Zweige, die hier und auf der Fernbedienung vorhanden sind

git push
git checkout test

Da der Titel "Best way" lautet, halte ich es für eine gute Idee, die Strategie der Geduldzusammenführung in Betracht zu ziehen .

Von: https://git-scm.com/docs/merge-strategies

Mit dieser Option verbringt 'Merge-Recursive' etwas mehr Zeit, um Fehlzusammenschlüsse zu vermeiden, die manchmal aufgrund unwichtiger übereinstimmender Linien auftreten (z. B. geschweifte Klammern aus unterschiedlichen Funktionen). Verwenden Sie diese Option, wenn die zusammenzuführenden Zweige stark voneinander abweichen. Siehe auch git-diff [1] --patience.

Verwendungszweck:

git fetch
git merge -s recursive -X patience origin/master

Git Alias

Ich benutze dafür immer einen Alias, zB einmal ausführen:

 git config --global alias.pmerge 'merge -s recursive -X patience'

Jetzt könnten Sie tun:

git fetch
git pmerge origin/master

Dies ist von GitLab: Folgen Sie einfach den Anweisungen:

Ich werde gemäß Entwicklungs- und Feature-Zweigen antworten.

Wenn Sie sich im Feature-Zweig befinden und ihn mit Develop aktualisieren müssen, verwenden Sie die folgenden Befehle: Git Checkout Develop Git Pull Git Checkout Feature / XYZ Git Merge Develop

Jetzt wird Ihre Funktion mit der Entwicklung aktualisiert. Sie können Ihre Änderungen übernehmen.