Wie hilft git mit dem folgenden Szenario umzugehen:

Ich habe eine Aufgabe in 2 Teile unterteilt: Backend-Aufgabe und Frontend-Aufgabe. Ich mache eine Pull-Anfrage, um die Backend-Änderungen zusammenzuführen und zu warten, bis sie zusammengeführt wurden (und um Feedback zu erhalten). Während des Wartens kann ich nicht wirklich an den Änderungen im Frontend arbeiten, da dies von den Änderungen im Backend abhängt und diese im Master-Zweig noch nicht verfügbar sind.

Was ist der beste Weg, um Änderungen in den Frontend-Änderungszweig aus dem Backend-Änderungszweig zu übernehmen, während dieser noch geprüft wird?

Ich habe dieses Problem auch manchmal. Git ist sehr flexibel. Hier ist eine Möglichkeit, wie Sie es tun können.

Ihre erste Filiale featureAsteht zur Überprüfung bereit.

Ihr zweiter Zweig featureBbefindet sich in der Entwicklung und hängt vom Code im featureAZweig ab.

Fügen Sie den featureAZweig in den featureBZweig ein.

Wenn Sie Änderungen an der featureAVerzweigung vornehmen, sollten Sie featureAdie featureBVerzweigung erneut in der Verzweigung zusammenführen, um die Änderungen zu übernehmen.

Sie sollten auch sicherstellen featureA, dass Sie zuerst featureBin den Haupt-Trunk einbinden featureA. Andernfalls werden Sie versehentlich auch einbinden , wenn Sie in den Haupt-Trunk einbinden . Sobald featureAes in den Hauptstamm übergeht, können Sie den featureAAst loswerden, da dies featureBjetzt nur noch vom Hauptstamm abhängt.

Ich bevorzuge es, wenn meine Feature-Zweige nicht voneinander abhängig sind, aber manchmal sind sie es und du musst damit rollen.

Warte einen Moment, überspringe das Zusammenführen

Für diesen Ansatz haben Sie nicht möchten , dass Ihr fusionieren feature_ain feature_bwiederholt.

Das Zurücksetzen wurde in anderen Antworten erwähnt, aber nur, um Dinge darauf zurückzusetzen master. Was Sie in Ihrem Fall tun möchten, ist:

• Starten Sie feature_bvon feature_a, dh:

  git checkout feature_a
  git checkout -b feature_b
  

• Wann immer sich etwas feature_aändert, während es darauf wartet, zusammengeführt zu werden master, stützen feature_b Sie sich darauf:

  ... commit something onto feature_a ...
  git checkout feature_b
  git rebase feature_a
  

• Sobald feature_aes in zusammengeführt wurde master, holen Sie sich einfach das neue masterund legen feature_aes ein letztes Mal neu auf:

  git checkout master
  git pull origin master
  git checkout feature_b
  git rebase --onto master feature_a feature_b
  

  Diese letzte Neuformulierung setzt alle Commits, die von dem feature_aCommit (das jetzt irrelevant ist, da es in das Commit eingebunden wurde) abhängen, masterdirekt auf master. Ihr feature_bist jetzt ein einfacher Standardzweig, von dem aus Sie direkt fortfahren master.

BEARBEITEN: Inspiriert von den Kommentaren, ein kleiner Hinweis: Wenn Sie Änderungen vornehmen müssen, die sich auf beide Funktionen feature_aauswirken , stellen Sie sicher, dass Sie die Änderungen vornehmen (und anschließend wie gezeigt erneut ausführen). Machen Sie es nicht in zwei verschiedenen Commits in beiden Zweigen, auch wenn es verlockend sein mag. Wie feature_aes Teil der Geschichte von feature_bist, wird es später möglicherweise zu Konflikten oder "Auferweckungen" von unerwünschtem Code führen, wenn die einzelne Änderung in zwei verschiedenen Commits semantisch falsch ist.

Sie haben bereits einen Zweig, von dem jeder Feature-Zweig abhängt und der sich ständig ändert. Es heißt master.

Die typische Methode, mit der ein Feature-Zweig synchron masterbleibt, besteht darin, den Überblick zu behalten . Bei masterÄnderungen befinden Sie sich normalerweise git fetch origin master:master && git rebase masterim Arbeitsverzeichnis Ihrer Filiale.

Mit einem anderen Feature-Zweig können Sie dasselbe tun: Sie können ihn weiterhin abrufen und darauf aufbauen.

Wenn Sie aus irgendeinem Grund Ihre Änderungen in einen anderen Zweig verschieben müssen, können Sie Ihre Commits auswählen , die niemals mit den Commits anderer Zweige gemischt werden.

In diesem Fall, in dem die Frontend-Task eine kritische Abhängigkeit vom Backend-Code aufweist und Sie die Arbeit am Frontend beginnen möchten, bevor das Backend fertiggestellt und auf dem Master akzeptiert wurde, starte ich die Frontend-Task einfach als Feature-Zweig, der von der stammt Backend-Verzweigung, anstatt das Frontend auf Master zu verzweigen.

Ein Feature-Zweig, der lange genug lebt, muss gelegentlich in Änderungen vom Master zusammengeführt werden (um sicherzustellen, dass Sie alle Zusammenführungen oder semantischen Konflikte als Teil der Entwicklungsarbeit am Feature-Zweig und nicht als Teil der "Überprüfung, qa, Zusammenführung" miteinander in Einklang bringen. Prozess zu meistern). Wenn Sie dies in Ihrem Front-End-Zweig tun und die Back-End-Arbeit als Master akzeptiert wurde, erhalten Sie alle geringfügigen Änderungen, die im Rahmen der Überprüfung / Annahme automatisch am Back-End vorgenommen wurden, auf dem gleichen Weg wie Sie Holen Sie sich alle anderen Code-Änderungen auf Master.

Wenn sich herausstellt, dass der Back-End-Zweig viel mehr Arbeit benötigt und sich über einen bestimmten Zeitraum hinweg ändert, bevor er zum Master zusammengeführt wird (z. B. wenn während der Überprüfung größere Probleme auftreten), möchten Sie wahrscheinlich regelmäßige Zusammenführungen direkt durchführen von der Backend-Verzweigung in die Frontend-Verzweigung (damit Sie nicht Ihre gesamte Frontend-Arbeit auf veralteten Backend-Code stützen). Dies ist einfach, wenn Sie der einzige Entwickler sind, der beide Funktionen ausführt (da Sie wissen, ob Sie selbst größere Änderungen vornehmen), aber selbst wenn beide Funktionen von verschiedenen Entwicklern parallel bearbeitet werden, sollte dies in Ordnung sein. Sie müssen nur in der Kommunikation bleiben (was Sie ohnehin benötigen würden, wenn Sie parallel an Aufgaben arbeiten, bei denen eine kritische Abhängigkeit von der anderen besteht).

Wenn sich herausstellt, dass die gesamte Backend-Verzweigung aufgegeben werden muss und niemals zusammengeführt wird (es scheint, als ob dies ein ziemlich wichtiger Deal wäre, der selten passieren würde), wählen Sie entweder Ihre Commits für eine neue Verzweigung aus, die vom Master kommt ohne die Backend-Arbeit oder Sie wenden Reverse Commits an, die den gesamten Backend-Code für den Frontend-Zweig entfernen. Aber wie ich sehen kann, würde es wahrscheinlicher sein, die Frontend-Arbeit anzuhalten, bis Sie herausgefunden haben, was das Backend ersetzen würde, das Sie herauswerfen, und dann zu entscheiden, was zu tun ist.

Ich sehe das Problem hier nicht.

Dies haben Sie bereits jedes Mal in Ihrer masterBranche, die sich ständig ändert, während Features entwickelt und dann zusammengeführt werden.

In Ihrem konkreten Beispiel legen Sie also zunächst die feature_xxx_backendVerzweigung an und entwickeln die Backend-Änderungen. In diesem Fall wird der Zweig überprüft und nach Abschluss masterder Überprüfung zusammengeführt.

Starten Sie einfach einen anderen Zweig feature_yyy_frontend. Sie werden wahrscheinlich direkt von dort verzweigen wollen feature_xxx_backend, damit Sie diese Änderungen bereits in Ihrer Datenbank haben. Entwickeln Sie dann einfach das Frontend-Feature, sobald die Verzweigung vorhanden ist master.

Wenn sich die feature_xxx_backendVerzweigung ändert, z. B. weil während der Überprüfung Dinge auftauchen, die behoben werden müssen, nehmen Sie diese Änderungen einfach vor und führen Sie sie in der feature_yyy_frontendVerzweigung zusammen. Fahren Sie dann mit dem Frontend-Zweig fort.

Sobald die Überprüfung des Backend-Zweigs abgeschlossen ist, wird es in zusammengeführt master. Zu diesem Zeitpunkt ist es ratsam, die feature_yyy_frontendVerzweigung auf eine neue Basis zu stellenmaster , sodass die Prüfer nur die neuen Änderungen überprüfen müssen, zu denen diese Verzweigung beiträgt master, und nicht die Änderungen, die für das Backend vorgenommen wurden (die bereits genehmigt wurden) ).

Dies ist auch möglich, wenn Sie zwei, drei oder mehr abhängige Zweige haben. Wenn Sie zwei Feature-Zweige haben, von denen Sie abhängig sind, erstellen Sie einfach einen abgeleiteten Zweig, in dem beide Features zusammengeführt wurden. Verzweigen Sie von dort aus, entwickeln Sie das dritte Feature und führen Sie beide Feature-Zweige zusammen, wenn sich diese ändern. Wenn beide Features fertig sind und entweder in den abgeleiteten Zweig eingefügt werden, führen Sie einen Neustart auf diesen Zweig durch, oder führen Sie einen Neustart auf den Master durch, wenn sie in den Master eingefügt werden.

Das erneute Einrichten (wie oben vorgeschlagen) ist sehr leistungsfähig und hilft dabei, ein sauberes Protokoll der Änderungen zu führen, wodurch Überprüfungen erheblich vereinfacht werden.

Wie Polygnome bereits erwähnt hat, können Sie Ihren Frontend-Zweig anstelle der Master mit Ihrem Backend-Zweig zusammenführen. Selbst mit dem aktuellen Zweig-Setup, das Sie jetzt haben, können Sie einfach Folgendes tun:

git checkout frontend
git merge backend

oder einfach

git merge backend frontend

Beachten Sie jedoch, dass Sie Aktualisierungen aus dem Backend in das Frontend einbinden müssen, um Konflikte zu vermeiden, wenn Änderungen am Backend nicht akzeptiert werden und mehr Arbeit erforderlich ist. Sobald die Änderungen in den Master übernommen wurden, können Sie Ihr Frontend auf den Master zurücksetzen, um die Backend-Merge-Commits zu beseitigen.

Technisch könnten Sie auch alles mit Rebase machen, aber das wird die Commit-Historie Ihres Frontend-Zweigs durcheinander bringen. Woher ich komme, wird dies als schlechte Praxis angesehen. YMMV

Die meisten Antworten hier beschreiben den Vorgang des Zusammenführens der Änderungen vom zweiten Zweig zum ersten Zweig korrekt, zeigen jedoch nicht auf, wie Sie die Anzahl der Konflikte, die Sie möglicherweise lösen müssen, minimieren können.

Wenn Sie zwei große Änderungen haben, die Sie einzeln überprüfen möchten (wie featureAund featureB), erstellen Sie eine PR, die NICHT zum Zusammenführen gedacht ist, sondern um frühzeitig Feedback zu einem PoC von zu erhalten featureA.

Die Leute werden in der Lage sein, es schnell zu überprüfen (es ist nur ein PoC), und das Ziel ist es, das allgemeine Design oder den Ansatz zu validieren.

Anschließend können Sie an Feature A weiterarbeiten, eine Pull-Anforderung dafür erstellen und an Feature B verzweigen und daran arbeiten.

Der große Unterschied ist, dass Sie jetzt damit rechnen können, dass featureAsich nichts radikal ändert: Das Design und der Ansatz wurden bereits validiert. Die Codeüberprüfung und die erforderlichen Änderungen sind möglicherweise eher subtil und lokal als "Woops, Sie benötigen einen anderen Ansatz". Dadurch wird die Menge an Arbeit minimieren , die Sie brauchen , später zu tun , um zu verschmelzen featureBauf featureA‚s - Code, unabhängig von der Methode Sie wählten.