Ich habe einige Änderungen an einer Datei vorgenommen, die einige Male als Teil einer Dateigruppe festgeschrieben wurde, aber jetzt möchte ich die Änderungen auf eine vorherige Version zurücksetzen.
Ich habe einen git log
zusammen mit einem git diff
gemacht, um die Revision zu finden, die ich brauche, habe aber nur keine Ahnung, wie ich die Datei in die Vergangenheit zurückversetzen kann.
Angenommen, der Hash des gewünschten Commits lautet c5f567
:
git checkout c5f567 -- file1/to/restore file2/to/restore
Die git checkout man-Seite enthält weitere Informationen.
Wenn Sie vor c5f567
zum Commit zurückkehren möchten, hängen Sie ~1
an (funktioniert mit einer beliebigen Zahl):
git checkout c5f567~1 -- file1/to/restore file2/to/restore
Als Randbemerkung war ich mit diesem Befehl immer unangenehm, weil er sowohl für gewöhnliche Dinge (Wechseln zwischen Zweigen) als auch für ungewöhnliche, destruktive Dinge (Verwerfen von Änderungen im Arbeitsverzeichnis) verwendet wird.
Sie können die an einer Datei vorgenommenen Änderungen schnell mit dem Befehl diff überprüfen:
git diff <commit hash> <filename>
Um eine bestimmte Datei zu diesem Commit zurückzusetzen, verwenden Sie den Befehl reset:
git reset <commit hash> <filename>
Möglicherweise müssen Sie die --hard
-Option verwenden, wenn Sie lokale Änderungen haben.
Ein guter Arbeitsablauf für das Verwalten von Wegpunkten ist das Verwenden von Tags zum sauberen Markieren von Punkten in der Timeline. Ich kann Ihren letzten Satz nicht ganz verstehen, aber was Sie vielleicht wollen, ist, dass sich ein Zweig von einem vorherigen Zeitpunkt unterscheidet. Verwenden Sie dazu den praktischen Checkout-Befehl:
git checkout <commit hash>
git checkout -b <new branch name>
Wenn Sie diese Änderungen zusammenführen möchten, können Sie dies gegen Ihre Hauptleitung zurückweisen:
git checkout <my branch>
git rebase master
git checkout master
git merge <my branch>
Sie können einen beliebigen Verweis auf ein Git-Commit verwenden, einschließlich des SHA-1, wenn dies am bequemsten ist. Der Punkt ist, dass der Befehl so aussieht:
git checkout [commit-ref] -- [filename]
git checkout -- foo
Dadurch wird foo
auf HEAD zurückgesetzt. Du kannst auch:
git checkout HEAD^ foo
für eine Revision zurück usw.
Um die zuletzt festgeschriebene Version wiederherzustellen, die am häufigsten benötigt wird, können Sie diesen einfacheren Befehl verwenden.
git checkout HEAD file/to/restore
Ich hatte gerade das gleiche Problem und fand diese Antwort am leichtesten zu verstehen (commit-ref
ist der SHA - Wert der Änderung im Protokoll, zu dem Sie zurückkehren möchten):
git checkout [commit-ref] [filename]
Dadurch wird diese alte Version in Ihrem Arbeitsverzeichnis gespeichert und Sie können sie von dort aus festlegen, wenn Sie möchten.
Wenn Sie wissen, wie viele Commits Sie zurückgehen müssen, können Sie Folgendes verwenden:
git checkout master~5 image.png
Dies setzt voraus, dass Sie sich im Zweig master
befinden und die gewünschte Version 5 Commits zurückgibt.
Ich glaube, ich habe es gefunden .... von http://www-cs-students.stanford.edu/~blynn/gitmagic/ch02.html
Manchmal möchten Sie einfach nur zurückgehen und jede Änderung ab einem bestimmten Punkt vergessen, weil sie alle falsch liegen.
Beginnen mit:
$ git log
hier sehen Sie eine Liste der letzten Commits und deren SHA1-Hashes.
Als nächstes geben Sie ein:
$ git reset --hard SHA1_HASH
um den Status eines bestimmten Commits wiederherzustellen und alle neueren Commits dauerhaft aus dem Datensatz zu löschen.
Das hat für mich funktioniert:
git checkout <commit hash> file
Dann bestätigen Sie die Änderung:
git commit -a
Sie müssen vorsichtig sein, wenn Sie "Rollback" sagen. Wenn Sie früher eine Version einer Datei im Commit $ A hatten und später zwei Änderungen in zwei separaten Commits $ B und $ C vorgenommen haben (was Sie also sehen, ist die dritte Iteration der Datei), und wenn Sie " Ich möchte zum ersten zurückkehren ", meinst du es wirklich so?
Wenn Sie die Änderungen sowohl der zweiten als auch der dritten Iteration entfernen möchten, ist dies sehr einfach:
$ git checkout $A file
und dann übergeben Sie das Ergebnis. Der Befehl fragt "Ich möchte die Datei aus dem durch das Festschreiben $ A aufgezeichneten Status auschecken".
Auf der anderen Seite wollten Sie die durch die zweite Iteration (d. H. Commit $ B) eingebrachte Änderung abschaffen, während Sie gleichzeitig das Commit von $ C für die Datei beibehalten und $ B wiederherstellen möchten
$ git revert $B
Beachten Sie, dass derjenige, der Commit $ B erstellt hat, möglicherweise nicht sehr diszipliniert war und möglicherweise völlig unzusammenhängende Änderungen in demselben Commit ausgeführt hat, und dass dieser Revert möglicherweise andere Dateien als file berührt - Sie sehen möglicherweise fehlerhafte Änderungen Ergebnis sorgfältig danach.
Komischerweise funktioniert 'git checkout foo' nicht, wenn sich die Arbeitskopie in einem Verzeichnis namens foo befindet. Sowohl "git checkout HEAD foo" als auch "git checkout ./foo" werden jedoch
$ pwd
/Users/aaron/Documents/work/foo
$ git checkout foo
D foo
Already on "foo"
$ git checkout ./foo
$ git checkout HEAD foo
So funktioniert rebase
:
git checkout <my branch> git rebase master git checkout master git merge <my branch>
Angenommen, du hast
---o----o----o----o master \---A----B <my branch>
Die ersten beiden Befehle ... Commit git checkout Git Rebase Meister
... checken Sie den Zweig der Änderungen aus, den Sie auf den Zweig master
anwenden möchten. Der Befehl rebase
übernimmt die Commits von <my branch>
(die nicht in master
gefunden werden) und wendet sie erneut auf den Kopf von master
an. Mit anderen Worten ist das übergeordnete Element des ersten Commits in <my branch>
nicht mehr ein vorheriges Commit in der master
-Historie, sondern der aktuelle Kopf von master
. Die beiden Befehle sind die gleichen wie:
git rebase master <my branch>
Es ist möglicherweise einfacher, sich an diesen Befehl zu erinnern, da sowohl die "Basis" - als auch die "Änderungszweige" explizit sind.
. Das Endergebnis ist:
---o----o----o----o master \----A'----B' <my branch>
Die letzten beiden Befehle ...
git checkout master
git merge <my branch>
... führen Sie einen Schnellvorlauf durch, um alle <my branch>
-Änderungen auf master
anzuwenden. Ohne diesen Schritt wird das Rebase-Commit nicht zu master
hinzugefügt. Das Endergebnis ist:
---o----o----o----o----A'----B' master, <my branch>
master
und <my branch>
beziehen sich beide auf B'
. Ab diesem Punkt ist es auch sicher, die <my branch>
-Referenz zu löschen.
git branch -d <my branch>
git-Aliase, awk und Shell-Funktionen zur Rettung!
git prevision <N> <filename>
dabei ist <N>
die Anzahl der Revisionen der Datei, die für die Datei <filename>
zurückgesetzt werden soll.
Um beispielsweise die unmittelbar vorhergehende Revision einer einzelnen Datei x/y/z.c
zu überprüfen, führen Sie Folgendes aus
git prevision -1 x/y/z.c
Fügen Sie Ihrer gitconfig
Folgendes hinzu:
[alias]
prevision = "!f() { git checkout `git log --oneline $2 | awk -v commit="$1" 'FNR == -commit+1 {print $1}'` $2;} ;f"
Der Befehl im Grunde
- führt ein
git log
für die angegebene Datei und aus- wählt die entsprechende Festschreibungs-ID in der Geschichte der Datei und aus
- führt ein
git checkout
für die festgelegte ID für die angegebene Datei aus.
Im Wesentlichen würde alles, was man in dieser Situation manuell tun würde,
verpackt in einem schönen, effizienten git-alias - git-prevision
Erster Kopf für Zieldatei zurücksetzen
git reset HEAD path_to_file
Zweite Überprüfung dieser Datei
git checkout -- path_to_file
In dem Fall, dass Sie eine Datei mit einem vorherigen Commit wiederherstellen möchten (und die Datei, die Sie bereits zurückgegeben haben möchten), können Sie sie verwenden
git checkout HEAD^1 path/to/file
oder
git checkout HEAD~1 path/to/file
Dann einfach die "neue" Version bereitstellen und festschreiben.
Ausgestattet mit dem Wissen, dass ein Commit bei einer Zusammenführung zwei Eltern haben kann, sollten Sie wissen, dass HEAD ^ 1 der erste Elternteil und HEAD ~ 1 der zweite Elternteil ist.
Beides funktioniert, wenn sich nur ein Elternteil im Baum befindet.
Ich muss EasyGit hier einstecken, was ein Wrapper ist, um git für Anfänger zugänglich zu machen, ohne erfahrene Benutzer zu verwirren. Eine der Sachen, die es tut, ist git revert
mehr Bedeutung geben. In diesem Fall würden Sie einfach sagen:
eg revertfoo/bar foo/baz
Beachten Sie jedoch, dass git checkout ./foo
und git checkout HEAD ./foo
Nicht genau dasselbe sind; Fallbeispiel:
$ echo A > foo
$ git add foo
$ git commit -m 'A' foo
Created commit a1f085f: A
1 files changed, 1 insertions(+), 0 deletions(-)
create mode 100644 foo
$ echo B >> foo
$ git add foo
$ echo C >> foo
$ cat foo
A
B
C
$ git checkout ./foo
$ cat foo
A
B
$ git checkout HEAD ./foo
$ cat foo
A
(Die zweite add
bereitet die Datei im Index auf, aber es wird not get Begangen.)
Git checkout ./foo
bedeutet Umkehrpfad ./foo
aus der index ; Durch das Hinzufügen von HEAD
wird Git angewiesen, diesen Pfad im Index auf seine HEAD
-Version zurückzusetzen.
Viele Vorschläge hier, am meisten nach git checkout $revision -- $file
. Ein paar obskure Alternativen:
git show $revision:$file > $file
Und ich benutze das auch oft, um vorübergehend eine bestimmte Version zu sehen:
git show $revision:$file
oder
git show $revision:$file | vim -R -
(OBS: $file
muss ./
vorangestellt werden, wenn es sich um einen relativen Pfad für git show $revision:$file
handelt)
Und das noch komischer:
git archive $revision $file | tar -x0 > $file
Für mich war keine der Antworten wirklich klar und deshalb möchte ich meine hinzufügen, was sehr einfach erscheint.
Ich habe ein Commit abc1
und danach habe ich mehrere (oder eine Änderung) an einer Datei file.txt
vorgenommen.
Nun sage ich, dass ich etwas in der Datei file.txt
vermasselt habe und ich möchte zu einem vorherigen Commit abc1
zurückkehren.
1 .git checkout file.txt
: Dadurch werden lokale Änderungen entfernt, wenn Sie sie nicht benötigen
2 .git checkout abc1 file.txt
: Dadurch wird Ihre Datei in Ihre wanted -Version gebracht
3 .git commit -m "Restored file.txt to version abc1"
: Damit wird Ihre Stornierung festgelegt.
git Push
: Dies wird alles im entfernten Repository pushen Zwischen den Schritten 2 und 3 können Sie natürlich git status
tun, um zu verstehen, was los ist. Normalerweise sollte der file.txt
bereits hinzugefügt werden, weshalb kein git add
erforderlich ist.
Um zu einer vorherigen Commit-Version der Datei zu gelangen, rufen Sie die Commit-Nummer ab, sagen Sie dann eb917a1 .__
git checkout eb917a1 YourFileName
Wenn Sie nur zur letzten festgeschriebenen Version zurückkehren müssen
git reset HEAD YourFileName
git checkout YourFileName
Dadurch gelangen Sie einfach zum letzten festgeschriebenen Status der Datei
git checkout ref | commitHash - filePath
z.B.
git checkout HEAD~5 -- foo.bar
or
git checkout 048ee28 -- foo.bar
Verwenden Sie git log
, um den Hash-Schlüssel für eine bestimmte Version abzurufen, und verwenden Sie dann git checkout <hashkey>
.
Hinweis: Vergessen Sie nicht, den Hash vor dem letzten einzugeben. Der letzte Hashpunkt zeigt Ihre aktuelle Position (HEAD) und ändert nichts.
Viele Antworten geben an, git reset ... <file>
oder git checkout ... <file>
zu verwenden, aber dadurch verlieren Sie alle Änderungen an <file>
, die nach dem Commit, den Sie rückgängig machen möchten, übernommen wurden.
Wenn Sie Änderungen von einem Commit nur für eine einzelne Datei wiederherstellen möchten, genau wie git revert
dies tun würde, aber nur für eine Datei (oder eine Teilmenge der Commit-Dateien), empfehle ich, git diff
und git apply
so zu verwenden (mit <sha>
= der Hash des Commits, das Sie zurücksetzen möchten):
git diff <sha>^ <sha> path/to/file.ext | git apply -R
Grundsätzlich wird zuerst ein Patch generiert, der den Änderungen entspricht, die Sie zurücksetzen möchten, und anschließend den Patch rückgängig machen, um die Änderungen zu löschen.
Natürlich funktioniert es nicht, wenn umgedrehte Zeilen durch ein Commit zwischen <sha1>
und HEAD
(Konflikt) geändert wurden.
Natürlich muss jemand entweder ein verständliches Buch über Git schreiben, oder Git muss in der Dokumentation besser erklärt werden. Angesichts dieses Problems habe ich das erraten
cd <working copy>
git revert master
würde das letzte Commit aufheben, was zu tun schien.
Ian
wenn Sie in Ihren letzten Commits eine falsche Datei festlegen, folgen Sie den Anweisungen:
git revert <hash>
Wird ein bestimmtes Commit rückgängig machen. Es klingt, als ob Sie denken, git revert
wirkt sich nur auf das letzte Commit aus.
Das löst Ihr Problem nicht, wenn Sie eine Änderung in einer bestimmten Datei rückgängig machen möchten und der Commit mehr als diese Datei geändert hat.
Sie können es in 4 Schritten machen:
Was müssen Sie in Ihr Terminal eingeben :
git revert <commit_hash>
git reset HEAD~1
git add <file_i_want_to_revert>
&& git commit -m 'reverting file'
git checkout .
viel Glück
Dies ist ein sehr einfacher Schritt. Checkout-Datei auf die Commit-ID, die wir möchten, hier eine Commit-ID vor, und dann einfach Commit change und fertig.
# git checkout <previous commit_id> <file_name>
# git commit --amend
Das ist sehr praktisch. Wenn wir eine Datei zu einer früheren Commit-ID am Anfang von Commit bringen möchten, können wir dies problemlos tun.
git checkout Last_Stable_commit_Number - Dateiname
2.Git Wiederherstellen der Datei in einem bestimmten Zweig
git checkout branchName_Which_Has_stable_Commit fileName
Hier ist mein Weg.
a) Öffnen Sie in Android Studio die Datei.
b) git -> Show History, finde den vorherigen Commit, zu dem ich zurückkehren möchte. Rufen Sie die Festschreibungs-ID ab (d. H. Einen Festschreibungshash).
c) git checkout commit_id file_path
Wenn Sie Git Extensions verwenden und nur zum übergeordneten Commit für die Datei zurückkehren möchten, können Sie das Commit auswählen, das die Änderungen enthält, die Sie rückgängig machen möchten. Wählen Sie dann im Detailbereich die Registerkarte 'Diff' und klicken Sie mit der rechten Maustaste die Datei, die Sie zurücksetzen möchten, dann 'Datei (en) zurücksetzen auf' ..., dann 'A' (das übergeordnete Element)
Ab git v2.23.0 gibt es eine neue git restore Methode, die einen Teil dessen übernehmen soll, wofür git checkout
verantwortlich war (selbst die akzeptierte Antwort erwähnt, dass git checkout
ziemlich verwirrend ist ). Höhepunkte der Änderungen finden Sie auf Github-Blog .
Das Standardverhalten dieses Befehls besteht darin, den Status eines Arbeitsbaums mit dem Inhalt wiederherzustellen, der aus dem Parameter source
stammt (in Ihrem Fall handelt es sich um einen Festschreibungs-Hash).
Basierend auf Greg Hewgills Antwort (vorausgesetzt, der Commit-Hash ist c5f567
) würde der Befehl folgendermaßen aussehen:
git restore --source=c5f567 file1/to/restore file2/to/restore
Oder wenn Sie den Inhalt eines Commits vor c5f567 wiederherstellen möchten:
git restore --source=c5f567~1 file1/to/restore file2/to/restore