Ich benutze git für ein neues Projekt, das zwei parallele, aber derzeit experimentelle Entwicklungszweige hat:
master
: Import der vorhandenen Codebase plus ein paar Mods, von denen ich im Allgemeinen überzeugt bin exp1
: Versuchszweig # 1exp2
: Versuchszweig # 2exp1
und exp2
stehen für zwei sehr unterschiedliche Architekturansätze. Bis ich weiter komme, habe ich keine Möglichkeit zu wissen, welche davon (wenn auch) funktionieren wird. Während ich in einem Zweig Fortschritte mache, habe ich manchmal Bearbeitungen, die für den anderen Zweig nützlich wären, und möchte nur diese zusammenführen.
Wie kann man selektive Änderungen von einem Entwicklungszweig zum anderen zusammenführen und alles andere hinterlassen?
Ansätze, die ich in Betracht gezogen habe:
git merge --no-commit
gefolgt von der manuellen Deaktivierung einer großen Anzahl von Bearbeitungen, die ich nicht zwischen den Zweigen gemeinsam machen möchte.
Manuelles Kopieren allgemeiner Dateien in ein temporäres Verzeichnis, gefolgt von git checkout
, um zum anderen Zweig zu gelangen, und dann weiteres manuelles Kopieren aus dem temporären Verzeichnis in den Arbeitsbaum.
Eine Variation des Obigen. Verzichten Sie jetzt auf die exp
-Verzweigungen und verwenden Sie zwei zusätzliche lokale Repositorys zum Experimentieren. Dadurch wird das manuelle Kopieren von Dateien einfacher.
Alle drei Ansätze wirken langwierig und fehleranfällig. Ich hoffe, es gibt einen besseren Ansatz. etwas, das einem Filterpfad-Parameter ähnelt, der git-merge
selektiver macht.
Sie verwenden den Befehl cherry-pick , um einzelne Commits aus einem Zweig zu erhalten.
Wenn sich die gewünschten Änderungen nicht in einzelnen Commits befinden, verwenden Sie die hier gezeigte Methode, um das Commit in einzelne Commits aufzuteilen . Grob gesagt, verwenden Sie git rebase -i
, um das ursprüngliche Commit zur Bearbeitung abzurufen, dann git reset HEAD^
, um Änderungen selektiv rückgängig zu machen, und dann git commit
, um dieses Bit als neues Commit im Verlauf festzuschreiben.
Es gibt eine andere Nice-Methode hier im Red Hat Magazine, wo sie git add --patch
oder möglicherweise git add --interactive
verwenden, wodurch Sie nur Teile eines Hunks hinzufügen können, wenn Sie verschiedene Änderungen in eine einzelne Datei aufteilen möchten (in dieser Seite suchen) "Teilt").
Nachdem Sie die Änderungen aufgeteilt haben, können Sie jetzt die gewünschten 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:
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.
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.
Lauf:
git checkout branchX file1
Dadurch wird die Version von file1
in branchX
abgerufen und file1
von Git automatisch zusammengeführt.
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
git commit
file1
nicht zusammenführen möchten und die Version im aktuellen Zweig beibehalten möchtenLauf
git checkout HEAD file1
file2
nicht zusammenführen möchten und nur die Version in branchX
Lauf
git checkout branchX file2
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.
Erstellen Sie (falls nicht erstellt) einen lokalen Zweig mit den Änderungen, die Sie übernehmen möchten.
$ git branch mybranch <base branch>
Wechseln Sie hinein.
$ git checkout mybranch
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>
Ziehen Sie alles von ihrem Zweig herunter.
$ git pull repos-w-changes branch-i-want
Sehen Sie sich die Commit-Protokolle an, um die gewünschten Änderungen zu sehen:
$ git log
Wechseln Sie wieder zu dem Zweig, in den Sie die Änderungen ziehen möchten.
$ git checkout originalbranch
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.
git diff branch_b > my_patch_file.patch
Erzeugt eine Patch-Datei mit dem Unterschied zwischen dem aktuellen Zweig und branch_b
git apply -p1 --include=pattern/matching/the/path/to/file/or/folder my_patch_file.patch
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.
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.