Wie lassen sich Änderungen selektiv aus einem anderen Zweig in Git zusammenführen oder auswählen?

Ich hatte genau das gleiche Problem, das Sie oben erwähnt haben. Aber ich fand dies klarer bei der Erklärung der Antwort.

Zusammenfassung:

• Überprüfen Sie die Pfade von dem Zweig, den Sie zusammenführen möchten.

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

  Hinweis: Es funktioniert auch ohne -- wie im verlinkten Post.

• oder um selektiv Hunks zusammenzuführen

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

  Verwenden Sie alternativ reset und fügen Sie dann die Option -p hinzu.

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

• Schließlich begehen

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

Um Dateien selektiv von einem Zweig in einen anderen Zweig zusammenzuführen, führen Sie Folgendes aus

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

dabei ist branchX der Zweig, aus dem Sie den aktuellen Zweig zusammenführen möchten.

Mit der Option --no-commit werden die von Git zusammengeführten Dateien in Szene gesetzt, ohne dass sie tatsächlich festgelegt werden. Auf diese Weise haben Sie die Möglichkeit, die zusammengeführten Dateien nach Belieben zu ändern und dann selbst festzulegen. 

Je nachdem, wie Sie Dateien zusammenführen möchten, gibt es vier Fälle:

1) Sie wollen eine echte Verschmelzung.

In diesem Fall akzeptieren Sie die zusammengeführten Dateien auf die Art und Weise, wie Git sie automatisch zusammengeführt hat, und legen Sie sie fest.

2) Es gibt einige Dateien, die Sie nicht zusammenführen möchten.

Beispielsweise möchten Sie die Version im aktuellen Zweig beibehalten und die Version in dem Zweig ignorieren, aus dem Sie zusammenführen.

Um die Version im aktuellen Zweig auszuwählen, führen Sie Folgendes aus:

git checkout HEAD file1

Dadurch wird die Version von file1 im aktuellen Zweig abgerufen und der file1 automatisch von Git überschrieben. 

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

Lauf:

git checkout branchX file1

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

4) Der letzte Fall ist, wenn Sie nur bestimmte Zusammenführungen in file1 auswählen möchten.

In diesem Fall können Sie den geänderten file1 direkt bearbeiten, ihn auf die gewünschte Version der file1-Version aktualisieren und anschließend ein Commit ausführen.

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

Um es mit einem Beispiel näher zu erläutern, nehmen Sie an, Sie möchten branchX in den aktuellen Zweig einbinden:

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

Anschließend führen Sie den Befehl git status aus, um den Status der geänderten Dateien anzuzeigen.

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 die Dateien sind, die git erfolgreich automatisch zusammengeführt hat. 

Dies bedeutet, dass Änderungen in den Variablen master und branchX für alle drei Dateien ohne Konflikte miteinander kombiniert wurden.

Sie können die Ausführung der Zusammenführung überprüfen, indem Sie den git diff --cached ausführen.

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

Wenn Sie eine Zusammenführung als unerwünscht empfinden, können Sie dies tun

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

Wenn Sie file1 nicht zusammenführen möchten und die Version im aktuellen Zweig beibehalten möchten

Lauf

git checkout HEAD file1

Wenn Sie file2 nicht zusammenführen möchten und nur die Version in branchX

Lauf

git checkout branchX file2

Wenn file3 automatisch zusammengeführt werden soll, tun Sie nichts.

Git hat es an dieser Stelle bereits zusammengeführt.

file4 oben ist eine fehlgeschlagene Zusammenführung von Git. Das heißt, es gibt Änderungen in beiden Zweigen, die in derselben Zeile auftreten. Hier müssen Sie die Konflikte manuell lösen. Sie können den zusammengeführten Vorgang verwerfen, indem Sie die Datei direkt bearbeiten oder den Befehl zum Auschecken für die Version in dem Zweig ausführen, zu dem file4 werden soll.

Vergiss nicht git commit.

Ich mag die obigen Ansätze nicht. Die Verwendung von Kirschpickel eignet sich hervorragend für die Auswahl einer einzigen Änderung. Es ist jedoch ein Schmerz, wenn Sie alle Änderungen mit Ausnahme einiger schlechter Änderungen vornehmen möchten. Hier ist mein Ansatz.

Es gibt kein --interactive-Argument, das Sie an git merge übergeben können.

Hier ist die Alternative:

Sie haben einige Änderungen am Zweig 'Feature' vorgenommen und möchten einige davon, aber nicht alle, auf eine nicht schlampige Art und Weise zu 'Master' bringen (d. H.

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

Umhüllen Sie also einfach, dass in einem Shell-Skript der Master in $ to und in $ from die Funktion geändert werden, und Sie können loslegen:

#!/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 aus git checkout und git add -p und könnte genau das sein, was 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.

Während einige dieser Antworten ziemlich gut sind, habe ich das Gefühl, dass keine der ursprünglichen Einschränkungen von OP tatsächlich beantwortet wurde: bestimmte Dateien aus bestimmten Zweigen auswählen. Diese Lösung macht das, kann jedoch langwierig sein, wenn viele Dateien vorhanden sind.

Nehmen wir an, Sie haben die Zweige master, exp1 und exp2. Sie möchten eine Datei aus jedem der experimentellen Zweige mit dem Master zusammenführen. Ich würde so etwas machen:

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

Dies gibt Ihnen in-Datei Unterschiede für jede der gewünschten Dateien. Nichts mehr. Nicht weniger. Es ist nützlich, dass Sie zwischen den Versionen radikal unterschiedliche Änderungen vorgenommen haben - in meinem Fall, wenn Sie eine App von Rails 2 auf Rails 3 ändern.

EDIT: Dies führt Dateien zusammen, führt jedoch eine intelligente Zusammenführung durch. Ich konnte nicht herausfinden, wie diese Methode zum Abrufen von In-File-Diff-Informationen verwendet werden kann (bei extremen Unterschieden kann dies dennoch der Fall sein. Ärgerliche Kleinigkeiten wie Leerzeichen werden wieder zusammengeführt, wenn Sie nicht die Option -s recursive -X ignore-all-space verwenden.)

Die Antwort von 1800 INFORMATION ist vollkommen richtig. Als git noob jedoch war "use git cherry pick" nicht genug für mich, um das herauszufinden, ohne ein bisschen mehr im Internet zu graben, also dachte ich, ich würde einen detaillierteren Leitfaden für den Fall veröffentlichen, dass sich jemand in einer anderen Branche befindet ähnliches Boot. 

Mein Use Case 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) einen lokalen Zweig mit den Änderungen, die Sie übernehmen möchten.

   $ git branch mybranch <base branch>

2. Wechseln Sie hinein.

   $ git checkout mybranch

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

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

4. Ziehen Sie alles von ihrem Zweig herunter.

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

5. Sehen Sie sich die Commit-Protokolle an, um die gewünschten Änderungen zu sehen:

   $ git log 

6. Wechseln Sie wieder zu dem Zweig, in den Sie die Änderungen ziehen möchten.

   $ git checkout originalbranch

7. Cherry wählt deine Commits nacheinander mit den Hashes aus.

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

Hut-Tipp: http://www.sourcemage.org/Git_Guide

So können Sie die Myclass.Java-Datei im master-Zweig durch Myclass.Java im feature1-Zweig ersetzen. Es funktioniert auch, wenn Myclass.Java nicht in master vorhanden ist.

git checkout master
git checkout feature1 Myclass.Java

Beachten Sie, dass dies überschreibt, nicht zusammengeführt wird und lokale Änderungen im Hauptzweig ignoriert werden.

Der einfache Weg, tatsächlich zusammenzuführen bestimmte Dateien aus zwei Zweigen, ersetzt nicht nur bestimmte Dateien durch Dateien aus einem anderen Zweig.

Schritt eins: Diff die Zweige

git diff branch_b > my_patch_file.patch

Erzeugt eine Patch-Datei mit dem Unterschied zwischen dem aktuellen Zweig und branch_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 * als Platzhalter im Include-Muster verwenden. 

Schrägstriche müssen nicht entkommen werden.

Sie können stattdessen auch --exclude verwenden und auf alles anwenden, außer auf die Dateien, die dem Muster entsprechen, oder den Patch mit -R rückgängig machen 

Die Option -p1 ist ein Überbleibsel des Befehls * unix patch und die Tatsache, dass der Inhalt der Patchdatei jedem Dateinamen a/ oder b/ (oder mehr, je nachdem, wie die Patchdatei erstellt wurde) voranstellen, die Sie entfernen müssen, damit dies möglich ist Ermitteln Sie die tatsächliche Datei im Pfad zu der Datei, auf die der Patch angewendet werden soll.

In der Manpage zu git-apply finden Sie weitere Optionen. 

Schritt drei: Es gibt keinen dritten Schritt

Natürlich möchten Sie Ihre Änderungen festschreiben, aber wer sagt noch, dass Sie keine anderen verwandten Optimierungen haben, die Sie vor dem Festschreiben tun möchten. 

So können Sie Geschichte mit nur wenigen Dateien aus einem anderen Zweig mit minimalem Aufwand nachverfolgen, auch wenn eine "einfachere" Zusammenführung viele weitere Änderungen mit sich gebracht hätte, die Sie nicht möchten.

Zuerst machen Sie den ungewöhnlichen Schritt, im Voraus zu erklären, dass das, was Sie jetzt begehen, eine Zusammenführung ist, ohne dass Sie die Dateien in Ihrem Arbeitsverzeichnis ändern müssen:

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

. . . wobei "branchname" das ist, von dem Sie behaupten, dass Sie es zusammenführen. Wenn Sie sofort ein Commit ausführen, werden keine Änderungen vorgenommen, es werden jedoch Vorfahren aus dem anderen Zweig angezeigt. Sie können weitere Zweige/Tags/etc hinzufügen. auf die Befehlszeile, wenn Sie müssen, auch. Zu diesem Zeitpunkt gibt es jedoch keine Änderungen, die festgeschrieben werden müssen. Als nächstes erhalten Sie die Dateien aus den anderen Revisionen.

git checkout branchname1 -- file1 file2 etc

Wenn Sie aus mehreren anderen Zweigen zusammengeführt wurden, wiederholen Sie den Vorgang bei Bedarf.

git checkout branchname2 -- file3 file4 etc

Nun befinden sich die Dateien aus dem anderen Zweig im Index und können mit der Historie festgeschrieben werden.

git commit

in dieser Commit-Nachricht müssen Sie viel erklären.

Bitte beachten Sie jedoch, falls es nicht klar war, dass dies eine versaute Sache ist. Es ist nicht im Sinne dessen, was ein "Zweig" ist, und Kirschpickel ist ein ehrlicherer Weg, um das zu tun, was Sie hier tun würden. Wenn Sie eine weitere "Zusammenführung" für andere Dateien in demselben Zweig vornehmen wollten, die Sie beim letzten Mal nicht übernommen haben, wird die Meldung "bereits auf dem neuesten Stand" angezeigt. Es ist ein Symptom der Verzweigung, wenn wir sollten, im Zweig "von" sollte es mehr als einen anderen Zweig geben.

Ich habe diesen Beitrag gefunden, um die einfachste Antwort zu 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

Siehe den Beitrag für weitere Informationen.

Ich weiß, dass ich etwas zu spät komme, aber dies ist mein Arbeitsablauf zum Zusammenführen selektiver 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

Am einfachsten ist es, wenn Sie Ihr Repo auf den Zweig setzen, mit dem Sie zusammenführen möchten, und dann ausführen.

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

Wenn du läufst 

git status

sie sehen die Datei bereits inszeniert ...

Dann renne 

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

Einfach. 

Es ist seltsam, dass git immer noch kein so praktisches Tool "out of the box" hat. Ich benutze es stark, wenn ich einen alten Versionszweig (der immer noch viele Software-Benutzer hat) mit nur einigen Bugfixes aus dem aktuellen Versionszweig aktualisiere. In diesem Fall ist es häufig erforderlich, schnell nur einige Codezeilen aus der Datei im Trunk abzurufen und viele andere Änderungen zu ignorieren (die nicht in die alte Version gehen sollen) ... und natürlich interaktive Dreiwege 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 einfach diese Zeile zum Abschnitt [alias] In Ihrer globalen .gitconfig Oder lokalen .git/config Datei hinzu:

[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;' -"

Dies setzt voraus, dass Sie Beyond Compare verwenden. Wechseln Sie bei Bedarf einfach zu einer Software Ihrer Wahl. Oder Sie können es auf automatische Drei-Wege-Zusammenführung umstellen, wenn Sie die interaktive selektive Zusammenführung 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 wie folgt:

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

Dies gibt Ihnen die Möglichkeit, selektiv Baumstruktur nur eine Datei in einem anderen Zweig zusammenzuführen.

Ich hatte genau das gleiche Problem, das Sie oben erwähnt haben. Aber ich habe diesen git Blog klarer bei der Erklärung der Antwort gefunden.

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...>

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 mag die "git-interactive-merge" -Antwort oben, aber es gibt eine einfachere Lösung. Lassen Sie git dies für Sie tun, indem Sie eine Rebase-Kombination von interaktiv und auf:

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

Der Fall ist, dass Sie C1 und C2 vom Zweig 'Feature' (Verzweigungspunkt 'A') wollen, aber vorerst keinen Rest.

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

Dadurch gelangen Sie wie oben in den interaktiven Editor, in dem Sie die 'Pick'-Zeilen für C1 und C2 auswählen (wie oben). Speichern und beenden Sie den Vorgang, und dann wird mit der Rebase fortgefahren, und Sie erhalten Zweig 'Temp' sowie HEAD an master + C1 + C2:

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

Dann können Sie master einfach auf HEAD aktualisieren und den temporären Zweig löschen. Nun können Sie loslegen:

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

Ich würde eine machen

git diff commit1..commit2 Dateipattern | git-apply --index && git commit

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

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

Ich weiß, dass diese Frage alt ist und es viele andere Antworten gibt, aber ich habe mein eigenes Skript namens "pmerge" geschrieben, um Verzeichnisse teilweise zusammenzuführen. 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 hebt dann Änderungen auf, die nicht mit dem angegebenen Pfad übereinstimmen.

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

Ich habe es nicht ausgiebig getestet. Das Arbeitsverzeichnis sollte frei von nicht festgeschriebenen Änderungen und nicht protokollierten 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

Was ist mit git reset --soft branch? Ich bin überrascht, dass noch niemand darüber gesprochen hat.

Für mich ist es der einfachste Weg, die Änderungen selektiv aus einem anderen Zweig auszuwählen, da dieser Befehl alle Diff-Änderungen in meinen Arbeitsbaum einfügt und ich einfach auswählen oder zurücksetzen kann, welchen ich benötige. Auf diese Weise habe ich die volle Kontrolle über die festgeschriebenen Dateien.

Sie können read-tree verwenden, um eine entfernte Baumstruktur in den aktuellen Index einzulesen oder zusammenzuführen. Beispiel:

git remote add foo [email protected]/foo.git
git fetch foo
git read-tree --prefix=my-folder/ -u foo/master:trunk/their-folder

Verwenden Sie für die Zusammenführung stattdessen -m.

Siehe auch: Wie füge ich ein Unterverzeichnis in git zusammen?

Ein einfacher Ansatz zum selektiven Zusammenführen/Festschreiben 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 sich nur wenige Dateien zwischen den aktuellen Commits der beiden Zweige geändert haben, füge ich die Änderungen manuell zusammen, indem ich die verschiedenen Dateien durchsehe.

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

Wenn Sie nur ein bestimmtes Verzeichnis zusammenführen müssen, alles andere intakt lassen und trotzdem die Historie beibehalten, können Sie dies versuchen. Erstellen Sie einen neuen target-branch aus der master, bevor Sie experimentieren.

Bei den folgenden Schritten wird davon ausgegangen, dass Sie über zwei Zweige target-branch und source-branch verfügen, und das Verzeichnis dir-to-merge, das Sie zusammenführen möchten, befindet sich im source-branch. Nehmen Sie außerdem an, Sie haben andere Verzeichnisse wie dir-to-retain im Ziel, die Sie nicht ändern und den Verlauf beibehalten möchten. Angenommen, es gibt Zusammenführungskonflikte im 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.

Wenn Sie nicht zu viele Dateien geändert haben, werden Sie keine zusätzlichen Commits ausführen.

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

2. Zum letzten gewünschten Commit zurücksetzen
$ git reset --hard HEAD~n, wobei n die Anzahl der Commits ist, die Sie zurückgehen müssen

3. Jede Datei von der ursprünglichen Niederlassung aus überprüfen
$ git checkout Origin/original_branch filename.ext

Jetzt können Sie, wenn nötig, Commit ausführen und Push (zum Überschreiben der Fernbedienung) erzwingen.