Wie fusionieren Sie Änderungen aus einem anderen Zweig in Git selektiv oder wählen Sie selektiv?

StackOverflow https://stackoverflow.com/questions/449541

Frage

Ich verwende Git für ein neues Projekt mit zwei parallelen - aber derzeit experimentellen - Entwicklungszweigen:

  • master: Import von vorhandener Codebasis plus ein paar Mods, der ich im Allgemeinen sicher bin
  • exp1: Experimenteller Zweig Nr. 1
  • exp2: Experimenteller Zweig Nr. 2

exp1 und exp2 darstellen zwei sehr unterschiedliche architektonische Ansätze. Bis ich weiter komme, kann ich nicht wissen, welches (wenn auch) funktionieren wird. Da ich in einem Zweig Fortschritte mache, habe ich manchmal Änderungen, die in der anderen Filiale nützlich wären und möchte nur diese verschmelzen.

Was ist der beste Weg, um selektive Veränderungen von einem Entwicklungszweig zu einem anderen zusammenzuführen, während Sie alles andere hinterlassen?

Ansätze, die ich in Betracht gezogen habe:

  1. git merge --no-commit gefolgt von manuellem Auflagen einer großen Anzahl von Änderungen, die ich zwischen den Zweigen nicht gemeinsam machen möchte.

  2. Manuelles Kopieren gemeinsamer Dateien in ein TEMP -Verzeichnis, gefolgt von gefolgt von git checkout Um in den anderen Zweig zu wechseln und dann mehr manuell aus dem TEMP -Verzeichnis in den Arbeitsbaum zu kopieren.

  3. Eine Variation des obigen. Aufgeben exp Zweige für den Moment und verwenden Sie zwei zusätzliche lokale Repositories für Experimente. Dies macht das manuelle Kopieren von Dateien viel einfacher.

Alle drei Ansätze scheinen mühsam und fehleranfällig zu sein. Ich hoffe, dass es einen besseren Ansatz gibt. etwas, das einem Filterpfadparameter ähnelt, der machen würde git-merge selektiver.

War es hilfreich?

Lösung

Sie verwenden die Kirschpick Befehl, um individuelle Commits von einer Niederlassung zu erhalten.

Wenn sich die gewünschten Änderungen nicht in einzelnen Commits befinden, verwenden Sie die hier gezeigte Methode zu Teilen Sie den Commit in einzelnen Commits auf. Grob gesagt, Sie verwenden git rebase -i Um das ursprüngliche Verpflichtung zum Bearbeiten zu erhalten, dann git reset HEAD^ Um Änderungen selektiv zurückzukehren, dann git commit so ein neues Commit in der Geschichte zu begehen.

Hier gibt es noch eine schöne Methode im Red Hat Magazine, wo sie verwenden git add --patch oder möglicherweise git add --interactive Auf diese Weise können Sie nur Teile eines Stücks hinzufügen, wenn Sie verschiedene Änderungen in eine einzelne Datei teilen möchten (suchen Sie in dieser Seite nach "Split").

Nachdem Sie die Änderungen geteilt haben, können Sie jetzt nur diejenigen, die Sie wollen, kehren.

Andere Tipps

Ich hatte genau das gleiche Problem wie oben erwähnt. Aber ich fand Dies klarer bei der Antwort zu erklären.

Zusammenfassung:

  • Checkout der Pfad (en) aus dem Zweig, den Sie zusammenführen möchten,

    $ git checkout source_branch -- <paths>...

    Hinweis: Es funktioniert auch ohne -- Wie im verknüpften Beitrag zu sehen.

  • oder selektiv Hunks verschmelzen

    $ git checkout -p source_branch -- <paths>...

    Verwenden Sie alternativ Reset und fügen Sie dann mit der Option hinzu -p,

    $ git reset <paths>...
$ git add -p <paths>...

  • Endlich verpflichten

    $ git commit -m "'Merge' these changes"

Um Dateien aus einer Niederlassung selektiv in einen anderen Zweig zu verschmelzen, laufen Sie aus

git merge --no-ff --no-commit branchX

wo branchX Ist der Zweig, von dem Sie sich in den aktuellen Zweig verschmelzen möchten.

Das --no-commit Die Option wird die Dateien inszeniert, die von Git zusammengeführt wurden, ohne sie tatsächlich zu begehen. Dies gibt Ihnen die Möglichkeit, die fusionierten Dateien zu ändern, wie Sie möchten, und sie dann selbst zu verpflichten.

Abhängig davon, wie Sie Dateien zusammenführen möchten, gibt es vier Fälle:

1) Sie möchten eine echte Zusammenführung.

In diesem Fall akzeptieren Sie die zusammengeführten Dateien so, wie Git sie automatisch verschmolzen und sie dann begehen.

2) Es gibt einige Dateien, die Sie nicht verschmelzen möchten.

Sie möchten beispielsweise die Version in der aktuellen Filiale behalten und die Version in der Filiale ignorieren, aus der Sie zusammenarbeiten.

Um die Version in der aktuellen Filiale auszuwählen, laufen Sie aus:

git checkout HEAD file1

Dadurch wird die Version von abgerufen file1 im aktuellen Zweig und überschreiben Sie die file1 von Git automatisiert.

3) Wenn Sie die Version in Branchx möchten (und keine echte Zusammenführung).

Laufen:

git checkout branchX file1

Dadurch wird die Version von abgerufen file1 in branchX und überschreiben file1 automatisch von Git.

4) Der letzte Fall ist, wenn Sie nur spezifische Zusammenschlüsse auswählen möchten file1.

In diesem Fall können Sie das geänderte bearbeiten file1 Aktualisieren Sie es direkt auf das, was Sie möchten, die Version von file1 zu werden und dann zu verpflichten.

Wenn Git eine Datei nicht automatisch zusammenführen kann, wird die Datei als "gemeldet"nicht vererbter"Und erstellen Sie eine Kopie, in der Sie die Konflikte manuell lösen müssen.


Um mit einem Beispiel weiter zu erklären, sagen wir an, Sie möchten zusammenarbeiten branchX in den aktuellen Zweig:

git merge --no-ff --no-commit branchX

Sie laufen dann die git status Befehl zum Anzeigen des Status von geänderten Dateien.

Zum Beispiel:

git status

# On branch master
# Changes to be committed:
#
#       modified:   file1
#       modified:   file2
#       modified:   file3
# Unmerged paths:
#   (use "git add/rm <file>..." as appropriate to mark resolution)
#
#       both modified:      file4
#

Wo file1, file2, und file3 sind die Dateien, die Git erfolgreich automatisch verhandelt haben.

Was dies bedeutet, ist, dass sich Änderungen in der master und branchX Für all diese drei Dateien wurden ohne Konflikte miteinander kombiniert.

Sie können untersuchen, wie die Zusammenführung durchgeführt wurde, indem Sie das ausführen git diff --cached;

git diff --cached file1
git diff --cached file2
git diff --cached file3

Wenn Sie etwas unerwünscht finden, können Sie es können

  1. Bearbeiten Sie die Datei direkt
  2. sparen
  3. git commit

Wenn Sie sich nicht verschmelzen wollen file1 und möchten die Version in der aktuellen Filiale behalten

Laufen

git checkout HEAD file1

Wenn Sie sich nicht verschmelzen wollen file2 und wollen nur die Version in branchX

Laufen

git checkout branchX file2

Falls Sie es wollen file3 Um automatisch zusammengeführt zu werden, tun Sie nichts.

Git hat es zu diesem Zeitpunkt bereits verschmolzen.


file4 Oben ist eine fehlgeschlagene Zusammenführung von Git. Dies bedeutet, dass in beiden Zweigen Änderungen auf derselben Linie auftreten. Hier müssen Sie die Konflikte manuell lösen. Sie können die zusammengeführte Fusionen verwerfen, indem Sie die Datei direkt bearbeiten oder den Checkout -Befehl für die Version in der gewünschten Filiale ausführen file4 werden.


Endlich nicht vergessen git commit.

Ich mag die oben genannten Ansätze nicht. Die Verwendung von Cherry-Pick ist ideal, um eine einzige Veränderung auszuwählen, aber es ist ein Schmerz, wenn Sie alle Änderungen mit Ausnahme einiger schlechter einbringen möchten. Hier ist mein Ansatz.

Es gibt kein --interactive Argument, das Sie an Git zusammengeben können.

Hier ist die Alternative:

Sie haben einige Änderungen in der Filiale "Funktion" und möchten einige, aber nicht alle von ihnen auf "Meister" auf nicht schlampige Weise übertragen (dh Sie möchten nicht jeden pflücken und jeden einzelnen begehen)

git checkout feature
git checkout -b temp
git rebase -i master

# Above will drop you in an editor and pick the changes you want ala:
pick 7266df7 First change
pick 1b3f7df Another change
pick 5bbf56f Last change

# Rebase b44c147..5bbf56f onto b44c147
#
# Commands:
# pick = use commit
# edit = use commit, but stop for amending
# squash = use commit, but meld into previous commit
#
# If you remove a line here THAT COMMIT WILL BE LOST.
# However, if you remove everything, the rebase will be aborted.
#

git checkout master
git pull . temp
git branch -d temp

Wickeln Sie das einfach in ein Shell -Skript ein, wechseln Sie den Master in $ zu und ändern Sie die Funktion in $ von und Sie sind gut zu gehen:

#!/bin/bash
# git-interactive-merge
from=$1
to=$2
git checkout $from
git checkout -b ${from}_tmp
git rebase -i $to
# Above will drop you in an editor and pick the changes you want
git checkout $to
git pull . ${from}_tmp
git branch -d ${from}_tmp

Es gibt einen anderen Weg:

git checkout -p

Es ist eine Mischung zwischen git checkout und git add -p Und könnte genau das sein, wonach Sie suchen:

   -p, --patch
       Interactively select hunks in the difference between the <tree-ish>
       (or the index, if unspecified) and the working tree. The chosen
       hunks are then applied in reverse to the working tree (and if a
       <tree-ish> was specified, the index).

       This means that you can use git checkout -p to selectively discard
       edits from your current working tree. See the “Interactive Mode”
       section of git-add(1) to learn how to operate the --patch mode.

Einige dieser Antworten sind zwar ziemlich gut, aber ich habe das Gefühl, dass keine tatsächlich die ursprüngliche Einschränkung von OP beantwortet hat: Auswählen bestimmter Dateien aus bestimmten Filialen. Diese Lösung erledigt das, kann aber mühsam sein, wenn es viele Dateien gibt.

Nehmen wir an, Sie haben das master, exp1, und exp2 Geäst. Sie möchten eine Datei aus jedem der experimentellen Zweige in den Master zusammenführen. Ich würde so etwas tun:

git checkout master
git checkout exp1 path/to/file_a
git checkout exp2 path/to/file_b

# save these files as a stash
git stash
# merge stash with master
git merge stash

Dadurch erhalten Sie Diffs in der File für jede der gewünschten Dateien. Nichts mehr. Nicht weniger. Es ist nützlich, dass Sie radikal unterschiedliche Dateiänderungen zwischen den Versionen haben-in meinem Fall wechseln eine App von Schienen 2 auf Schienen 3.

BEARBEITEN: Dies wird Dateien verschmelzen, aber eine intelligente Zusammenführung. Ich konnte nicht herausfinden, wie ich diese Methode mithilfe dieser Methode verwenden soll, um Informationen in der Datei zu erhalten -s recursive -X ignore-all-space Möglichkeit)

Die Antwort von 1800 Informationen ist völlig korrekt. Als Git Noob nicht genug "Verwenden Sie Git Cherry-Pick" nicht genug, um dies herauszufinden, ohne ein bisschen mehr im Internet zu graben Ähnliches Boot.

Mein Anwendungsfall wollte selektiv Änderungen aus dem Github -Zweig eines anderen in meinen eigenen ziehen. Wenn Sie bereits eine lokale Niederlassung mit den Änderungen haben, müssen Sie nur die Schritte 2 und 5-7 ausführen.

  1. Erstellen Sie (falls nicht erstellt) eine lokale Niederlassung mit den Änderungen, die Sie einführen möchten.

    $ git branch mybranch <base branch>

  2. Wechseln Sie hinein.

    $ git checkout mybranch

  3. Ziehen Sie die gewünschten Änderungen vom Konto der anderen Person ab. Wenn Sie es noch nicht getan haben, möchten Sie sie als Fernbedienung hinzufügen.

    $ git remote add repos-w-changes <git url>

  4. Zieh alles von ihrem Zweig herunter.

    $ git pull repos-w-changes branch-i-want

  5. Sehen Sie sich die Commit -Protokolle an, um zu sehen, welche Änderungen Sie möchten:

    $ git log

  6. Wechseln Sie zurück in den Zweig, den Sie in die Änderungen ziehen möchten.

    $ git checkout originalbranch

  7. Cherry wählen Sie Ihre Commits nacheinander mit den Hashes aus.

    $ git cherry-pick -x hash-of-commit

Hutspitze: http://www.sourcemage.org/git_guide

So können Sie ersetzen Myclass.java Datei in master Zweig mit Myclass.java in feature1 Zweig. Es wird funktionieren, auch wenn Myclass.java existiert nicht weiter master.

git checkout master
git checkout feature1 Myclass.java

Beachten Sie, dass dies überschreibt - nicht verschmelzen - und ignorieren lokale Änderungen im Master -Zweig eher.

Der einfache Weg, tatsächlich verschmelzen Bestimmte Dateien aus zwei Filialen ersetzen nicht nur bestimmte Dateien durch eine aus einer anderen Filiale.

Schritt eins: Diff der Zweige

git diff branch_b > my_patch_file.patch

Erstellt eine Patch -Datei über den Unterschied zwischen dem aktuellen Zweig und der Zweigstelle_B

Schritt 2: Wenden Sie den Patch auf Dateien an, die einem Muster entsprechen

git apply -p1 --include=pattern/matching/the/path/to/file/or/folder my_patch_file.patch

Nützliche Hinweise zu den Optionen

Sie können verwenden * Als Wildcard im Einschlussmuster.

Schrägstriche müssen nicht entkommen werden.

Sie können auch stattdessen -exklusten und auf alles anwenden, außer den Dateien, die mit dem Muster übereinstimmen, oder den Patch mit -R umkehren

Die Option -p1 ist ein Holdover aus dem Befehl *unix Patch und die Tatsache, dass der Inhalt der Patch -Datei jeden Dateinamen mit vorbereitet a/ oder b/ (oder mehr, je nachdem, wie die Patch -Datei generiert wurde), die Sie ausziehen müssen, damit sie die reale Datei zum Pfad zur Datei ermitteln kann, auf die der Patch angewendet werden muss.

Weitere Optionen finden Sie auf der Mannseite für Git-Apply.

Schritt drei: Es gibt keinen Schritt drei

Offensichtlich möchten Sie Ihre Änderungen begehen, aber wer sagt, dass Sie keine anderen verwandten Verbesserungen haben, die Sie vor dem Festlegen vornehmen möchten.

So können Sie die Geschichte erhalten, um nur ein paar Dateien aus einer anderen Filiale mit einem Minimum an Aufhebens zu folgen, auch wenn eine "einfachere" Zusammenführung viel mehr Änderungen vorgenommen hätte, die Sie nicht wollen.

Zunächst machen Sie den ungewöhnlichen Schritt, im Voraus zu erklären, dass das, was Sie gerade begehen, eine Zusammenführung ist, ohne dass Git in Ihrem Arbeitsverzeichnis überhaupt etwas mit den Dateien unternimmt:

git merge --no-ff --no-commit -s ours branchname1

. . . Woher "Branchname" ist, was Sie behaupten, sich zu verschmelzen. Wenn Sie sich sofort verpflichten würden, würde es keine Änderungen vornehmen, aber es würde immer noch Vorfahren aus dem anderen Zweig zeigen. Sie können weitere Zweige/Tags/etc hinzufügen. in die Befehlszeile, wenn Sie brauchen, auch. Zu diesem Zeitpunkt gibt es jedoch keine Änderungen zu begehen. Holen Sie sich also die Dateien aus den anderen Revisionen, als nächstes.

git checkout branchname1 -- file1 file2 etc

Wenn Sie von mehr als einem anderen Zweig verschmelzen, wiederholen Sie dies bei Bedarf.

git checkout branchname2 -- file3 file4 etc

Jetzt befinden sich die Dateien aus der anderen Filiale im Index, bereit zu werden, mit Geschichte zu verpflichten.

git commit

Und Sie werden viel erklären, um diese Commit -Nachricht zu tun.

Bitte beachten Sie jedoch, dass dies nicht klar ist, dass dies durcheinander ist. Es ist nicht im Geiste dessen, wofür ein "Zweig" ist, und Cherry-Pick ist eine ehrlichere Art, hier das zu tun, was Sie tun würden. Wenn Sie eine weitere "Zusammenführung" für andere Dateien in derselben Filiale durchführen wollten, die Sie beim letzten Mal nicht eingestellt haben, wird es Sie mit einer "bereits aktuellen" Nachricht aufhalten. Es ist ein Symptom, sich nicht zu verzweigen, wenn wir sollten, in der "From" -Ast sollte mehr als ein anderer Zweig sein.

Ich weiß, dass ich etwas spät dran bin, aber dies ist mein Workflow für das Zusammenführen von selektiven Dateien.

#make a new branch ( this will be temporary)
git checkout -b newbranch
# grab the changes 
git merge --no-commit  featurebranch
# unstage those changes
git reset HEAD
(you can now see the files from the merge are unstaged)
# now you can chose which files are to be merged.
git add -p
# remember to "git add" any new files you wish to keep
git commit

ich fand dieser Beitrag die einfachste Antwort enthalten. Nur tun:

$ #git checkout <branch from which you want files> <file paths>

Beispiel:

$ #pulling .gitignore file from branchB into current branch
$ git checkout branchB .gitignore

Weitere Informationen finden Sie im Beitrag.

Der einfachste Weg ist es, Ihr Repo in den Zweig zu setzen, mit dem Sie zusammenarbeiten möchten, dann rennen Sie.

git checkout [branch with file] [path to file you would like to merge]

Wenn du läufst 

git status

Sie werden die bereits inszenierte Datei sehen ...

Dann renne 

git commit -m "Merge changes on '[branch]' to [file]"

Einfach.

Es ist seltsam, dass Git immer noch kein so bequemes Werkzeug "aus der Box" hat. Ich benutze es stark, wenn ich eine alte Versionsbranche aktualisiere (die immer noch viele Software -Benutzer hat) von nur etwas Bugfixes aus der aktuellen Versionszweig. In diesem Fall ist es oft erforderlich, schnell zu bekommen nur etwas Codezeilen aus der Datei im Kofferraum und ignorieren viele andere Änderungen (die nicht in die alte Version gehen sollen) ... und natürlich Interaktiver Drei-Wege Zusammenführung ist in diesem Fall erforderlich, git checkout --patch <branch> <file path> ist für diesen selektiven Zusammenführungszweck nicht verwendbar.

Sie können es leicht tun:

Fügen Sie diese Zeile einfach hinzu [alias] Abschnitt in Ihrem globalen Abschnitt .gitconfig oder lokal .git/config Datei: 

[alias]
    mergetool-file = "!sh -c 'git show $1:$2 > $2.theirs; git show $(git merge-base $1 $(git rev-parse HEAD)):$2 > $2.base; /C/BCompare3/BCompare.exe $2.theirs $2 $2.base $2; rm -f $2.theirs; rm -f $2.base;' -"

Es impliziert, dass Sie über Vergleichen hinaus verwenden. Wechseln Sie bei Bedarf auf Software Ihrer Wahl. Oder Sie können es in Drei-Wege-Auto-Merge ändern, wenn Sie die interaktive Selektivverschmelzung nicht benötigen: 

[alias]
    mergetool-file = "!sh -c 'git show $1:$2 > $2.theirs; git show $(git merge-base $1 $(git rev-parse HEAD)):$2 > $2.base; git merge-file $2 $2.base $2.theirs; rm -f $2.theirs; rm -f $2.base;' -"

Dann benutze so: 

git mergetool-file <source branch> <file path>

Dies gibt Ihnen das wahre Selektive Baum Fusion Opportunity einer Datei in einer anderen Filiale.

Es ist nicht genau das, wonach Sie gesucht haben, aber es war für mich nützlich:

git checkout -p <branch> -- <paths> ...

Es ist eine Mischung aus einigen Antworten.

Ich hatte genau das gleiche Problem wie oben erwähnt. Aber ich fand Dieser Git -Blog klarer bei der Antwort zu erklären.

Befehl aus dem obigen Link:

#You are in the branch you want to merge to
git checkout <branch_you_want_to_merge_from> <file_paths...>

Ich würde eine machen

Git Diff Commit1..Commit2 filePattrenn | Git-Apply-Index && Git Commit

Auf diese Weise können Sie den Commit -Bereich für einen Filepattern aus einem Zweig einschränken.

Gestohlen von: http://www.gelato.unsw.edu.au/archives/git/0701/37964.html

Ich mag die Antwort "Git-Interactive-Merge" oben, aber es gibt eine einfachere. Lassen Sie dies für Sie für Sie mit einer Rebase -Kombination aus interaktiv und auf:

      A---C1---o---C2---o---o feature
     /
----o---o---o---o master

Der Fall ist also, dass Sie C1 und C2 aus "Feature" -Ag (Zweigpunkt 'a') aus "Feature"), aber keiner der anderen vorerst.

# git branch temp feature
# git checkout master
# git rebase -i --onto HEAD A temp

Was Sie wie oben in den interaktiven Editor fallen lassen, wo Sie die Zeilen "Auswahl" für C1 und C2 (wie oben) auswählen. Speichern und beenden, und dann wird es mit der Rebase fortgesetzt und geben Ihnen Zweig -Temperatur und gehen Sie auch bei Master + C1 + C2:

      A---C1---o---C2---o---o feature
     /
----o---o---o---o-master--C1---C2 [HEAD, temp]

Dann können Sie den Master einfach aktualisieren, um den Tempo -Zweig zu löschen, und Sie können loslegen:

# git branch -f master HEAD
# git branch -d temp

Ich weiß, dass diese Frage alt ist und es viele andere Antworten gibt, aber ich habe mein eigenes Skript mit dem Titel "PMERGE" geschrieben, um Verzeichnisse teilweise zu verschmelzen. Es ist eine Arbeit in Arbeit und ich lerne immer noch sowohl Git- als auch Bash -Scripting.

Dieser Befehl verwendet git merge --no-commit Und dann Unantragsänderungen, die nicht dem bereitgestellten Pfad übereinstimmen.

Verwendungszweck: git pmerge branch path
Beispiel: git merge develop src/

Ich habe es nicht ausgiebig getestet. Das Arbeitsverzeichnis sollte frei von nicht verbindlichen Änderungen und nicht zusammengezogenen Dateien sein.

#!/bin/bash

E_BADARGS=65

if [ $# -ne 2 ]
then
    echo "Usage: `basename $0` branch path"
    exit $E_BADARGS
fi

git merge $1 --no-commit
IFS=$'\n'
# list of changes due to merge | replace nulls w newlines | strip lines to just filenames | ensure lines are unique
for f in $(git status --porcelain -z -uno | tr '\000' '\n' | sed -e 's/^[[:graph:]][[:space:]]\{1,\}//' | uniq); do
    [[ $f == $2* ]] && continue
    if git reset $f >/dev/null 2>&1; then
        # reset failed... file was previously unversioned
        echo Deleting $f
        rm $f
    else
        echo Reverting $f
        git checkout -- $f >/dev/null 2>&1
    fi
done
unset IFS

Wie wäre es mit git reset --soft branch ? Ich bin überrascht, dass es noch niemand erwähnt hat.

Für mich ist es der einfachste Weg, die Änderungen aus einem anderen Zweig selektiv auszuwählen, da dieser Befehl meinen Arbeitsbaum, alle Diff -Änderungen einfügt, und ich kann leicht herausfinden oder zurückkehren, die ich brauche. Auf diese Weise habe ich die engagierten Dateien voll kontrolliert.

Sie können verwenden read-tree Zum Beispiel in den aktuellen Index gelesen oder zusammengefügt, z. B. in den aktuellen Index:

git remote add foo git@example.com/foo.git
git fetch foo
git read-tree --prefix=my-folder/ -u foo/master:trunk/their-folder

Verwenden Sie zur Durchführung von Zusammenführungen -m stattdessen.

Siehe auch: Wie fusioniere ich ein Sub -Verzeichnis in Git?

Ein einfacher Ansatz für selektives Zusammenführen/Begehen nach Datei:

git checkout dstBranch git merge srcBranch // make changes, including resolving conflicts to single files git add singleFile1 singleFile2 git commit -m "message specific to a few files" git reset --hard # blow away uncommitted changes

Wenn Sie nicht zu viele Dateien haben, die sich geändert haben, werden Sie keine zusätzlichen Commits hinterlassen.

1. Branch vorübergehend duplizieren
$ git checkout -b temp_branch

2. Zurücksetzen, um letztes gewolltes Commit zu sein
$ git reset --hard HEAD~n, wo n Ist die Anzahl der Commits, die Sie zurückgehen müssen

3. Checkout jeder Datei aus Originalzweig
$ git checkout origin/original_branch filename.ext

Jetzt können Sie bei Bedarf Push und Force Push (zum Überschreiben von Fernbedienung) begehen und erzwingen.

Wenn sich nur wenige Dateien zwischen den aktuellen Commits der beiden Zweige geändert haben, fusioniere ich die Änderungen manuell, indem ich die verschiedenen Dateien durchläufe.

git difftoll <branch-1>..<branch-2>

Wenn Sie nur ein bestimmtes Verzeichnis zusammenführen und alles andere intakt lassen und die Geschichte erhalten können, können Sie dies möglicherweise versuchen ... Erstellen Sie ein neues target-branch aus dem master Bevor Sie experimentieren.

Die folgenden Schritte gehen davon aus, dass Sie zwei Zweige haben target-branch und source-branch, und das Verzeichnis dir-to-merge Dass du zusammenführen willst, ist in der source-branch. Nehmen Sie auch an, Sie haben andere Verzeichnisse wie dir-to-retain In dem Ziel, dass Sie sich nicht ändern und die Geschichte behalten möchten. Angenommen, es gibt zusammengeführte Konflikte in der dir-to-merge.

git checkout target-branch
git merge --no-ff --no-commit -X theirs source-branch
# the option "-X theirs", will pick theirs when there is a conflict. 
# the options "--no--ff --no-commit" prevent a commit after a merge, and give you an opportunity to fix other directories you want to retain, before you commit this merge.

# the above, would have messed up the other directories that you want to retain.
# so you need to reset them for every directory that you want to retain.
git reset HEAD dir-to-retain
# verify everything and commit.
Lizenziert unter: CC-BY-SA mit Zuschreibung
Nicht verbunden mit StackOverflow
scroll top