Wie kann ich eine Datei auf eine bestimmte Revision zurücksetzen oder zurücksetzen?

Ich habe einige Änderungen an einer Datei vorgenommen, die einige Male als Teil einer Gruppe von Dateien festgeschrieben wurde, möchte aber jetzt die Änderungen daran zurücksetzen / auf eine frühere Version zurücksetzen.

Ich habe git logzusammen mit a git diffdie Revision gefunden, die ich benötige, habe aber keine Ahnung, wie ich die Datei in den früheren Zustand zurückversetzen kann.

Angenommen, der Hash des gewünschten Commits lautet c5f567:

git checkout c5f567 -- file1/to/restore file2/to/restore

Die git checkout Manpage gibt weitere Informationen.

Wenn Sie zuvor zum Commit zurückkehren möchten c5f567, hängen Sie an ~1(wobei 1 die Anzahl der Commits ist, die Sie zurückgehen möchten, kann dies alles sein):

git checkout c5f567~1 -- file1/to/restore file2/to/restore

Nebenbei bemerkt, ich habe mich mit diesem Befehl immer unwohl gefühlt, weil er sowohl für gewöhnliche Dinge (Wechsel zwischen Zweigen) als auch für ungewöhnliche, destruktive Dinge (Verwerfen von Änderungen im Arbeitsverzeichnis) verwendet wird.

Mit dem Befehl diff können Sie die an einer Datei vorgenommenen Änderungen schnell überprüfen:

git diff <commit hash> <filename>

Verwenden Sie dann den Befehl reset, um eine bestimmte Datei auf dieses Commit zurückzusetzen:

git reset <commit hash> <filename>

Möglicherweise müssen Sie die --hardOption verwenden, wenn Sie lokale Änderungen vorgenommen haben.

Ein guter Workflow für die Verwaltung von Wegpunkten besteht darin, Tags zu verwenden, um Punkte in Ihrer Zeitleiste sauber zu markieren. Ich kann Ihren letzten Satz nicht ganz verstehen, aber Sie möchten vielleicht einen Zweig von einem früheren Zeitpunkt abweichen. Verwenden Sie dazu den praktischen Checkout-Befehl:

git checkout <commit hash>
git checkout -b <new branch name>

Sie können dies dann für Ihre Hauptlinie neu festlegen, wenn Sie bereit sind, diese Änderungen zusammenzuführen:

git checkout <my branch>
git rebase master
git checkout master
git merge <my branch>

Sie können jeden 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

Das wird fooauf HEAD zurückgesetzt. Du kannst auch:

git checkout HEAD^ foo

für eine Revision zurück usw.

Um zur zuletzt festgeschriebenen Version zurückzukehren, 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 einfachsten zu verstehen ( commit-refist der SHA-Wert der Änderung in dem Protokoll, zu dem Sie zurückkehren möchten):

git checkout [commit-ref] [filename]

Dadurch wird diese alte Version in Ihr Arbeitsverzeichnis aufgenommen und von dort aus können Sie sie festschreiben, wenn Sie möchten.

Wenn Sie wissen, wie viele Commits Sie benötigen, um zurückzukehren, können Sie Folgendes verwenden:

git checkout master~5 image.png

Dies setzt voraus, dass Sie sich in der masterVerzweigung befinden und die gewünschte Version 5 Commits zurück ist.

Ich glaube, ich habe es gefunden ... von http://www-cs-students.stanford.edu/~blynn/gitmagic/ch02.html

Manchmal möchte man einfach zurückgehen und jede Änderung nach einem bestimmten Punkt vergessen, weil sie alle falsch sind.

Beginnen mit:

$ git log

Hier sehen Sie eine Liste der letzten Commits und deren SHA1-Hashes.

Geben Sie als Nächstes Folgendes 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 bei mir funktioniert:

git checkout <commit hash> file

Übernehmen Sie dann die Änderung:

git commit -a

Sie müssen vorsichtig sein, wenn Sie "Rollback" sagen. Wenn Sie früher eine Version einer Datei in 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 sagen " Ich möchte zum ersten zurückkehren ", meinst du das wirklich so?

Wenn Sie die Änderungen sowohl bei der zweiten als auch bei der dritten Iteration entfernen möchten, ist dies ganz einfach:

$ git checkout $A file

und dann legen Sie das Ergebnis fest. Der Befehl fragt "Ich möchte die Datei aus dem Status auschecken, der vom Commit $ A aufgezeichnet wurde".

Auf der anderen Seite wollten Sie die Änderung entfernen, die durch die zweite Iteration (dh Commit $ B) eingeführt wurde, und dabei beibehalten, was Commit $ C für die Datei getan hat. Sie möchten $ B zurücksetzen

$ git revert $B

Beachten Sie, dass wer auch immer $ B begehen nicht erstellt haben sehr diszipliniert und völlig unabhängig Änderung begangen haben , können in der gleichen begehen, und diese revert andere Dateien als berühren Datei Sie Änderungen sehen zu verletzen, so dass Sie das Ergebnis sorgfältig nach dem Handeln überprüfen möchten damit.

Amüsanterweise funktioniert git checkout fooes nicht, wenn sich die Arbeitskopie in einem Verzeichnis mit dem Namen befindet foo. jedoch beides git checkout HEAD foound git checkout ./foowird:

$ pwd
/Users/aaron/Documents/work/foo
$ git checkout foo
D   foo
Already on "foo"
$ git checkout ./foo
$ git checkout HEAD foo

So rebasefunktioniert es:

git checkout <my branch>
git rebase master
git checkout master
git merge <my branch>

Angenommen, Sie haben

---o----o----o----o  master
    \---A----B       <my branch>

Die ersten beiden Befehle ... Commit Git Checkout Git Rebase Master

... überprüfen Sie den Zweig der Änderungen, die Sie auf den masterZweig anwenden möchten . Der rebaseBefehl nimmt die Commits von <my branch>(die nicht in gefunden werden master) und wendet sie erneut auf den Kopf von an master. Mit anderen Worten, das übergeordnete Element des ersten Commits in <my branch>ist kein vorheriges Commit mehr in der masterHistorie, sondern der aktuelle Leiter von master. Die beiden Befehle sind dieselben wie:

git rebase master <my branch>

Es ist möglicherweise einfacher, sich an diesen Befehl zu erinnern, da sowohl die Zweige "base" als auch "modify" explizit sind.

. Das endgültige Ergebnis der Geschichte ist:

---o----o----o----o   master
                   \----A'----B'  <my branch>

Die letzten beiden Befehle ...

git checkout master
git merge <my branch>

... führen Sie eine Schnellvorlaufzusammenführung durch, um alle <my branch>Änderungen zu übernehmen master. Ohne diesen Schritt wird das Rebase-Commit nicht hinzugefügt master. Das Endergebnis ist:

---o----o----o----o----A'----B'  master, <my branch>

masterund <my branch>beide Referenz B'. Ab diesem Punkt ist es auch sicher, die <my branch>Referenz zu löschen .

git branch -d <my branch>

Ab Git v2.23.0 gibt es eine neue Git-Wiederherstellungsmethode , die einen Teil dessen übernehmen soll, wofür git checkoutverantwortlich war (selbst die akzeptierte Antwort erwähnt, dass dies git checkoutziemlich verwirrend ist). Die Höhepunkte der Änderungen finden Sie im Github-Blog .

Das Standardverhalten dieses Befehls besteht darin, den Status eines Arbeitsbaums mit dem Inhalt wiederherzustellen, der aus dem sourceParameter stammt (in Ihrem Fall ein Commit-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

Erster Kopf für Zieldatei zurücksetzen

git reset HEAD path_to_file

Zweiter Checkout dieser Datei

git checkout -- path_to_file

Git-Aliase, awk und Shell-Funktionen zur Rettung!

git prevision <N> <filename>

wo <N>ist die Anzahl der Revisionen der Datei zu Rollbacks für Datei <filename>. Führen
Sie beispielsweise aus, um die sofortige vorherige Revision einer einzelnen Datei x/y/z.causzuchecken

git prevision -1 x/y/z.c

Wie funktioniert Git Prevision?

Fügen Sie Folgendes zu Ihrem hinzu gitconfig

[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 logfür die angegebene Datei und aus
• wählt die entsprechende Commit-ID im Verlauf der Datei aus und
• führt eine git checkoutCommit-ID für die angegebene Datei aus.

Im Wesentlichen alles, was man in dieser Situation manuell tun würde,
zusammengefasst in einem schönen, effizienten Git-Alias ​​- Git-Prevision

Ich muss hier EasyGit einstecken , ein Wrapper, um Git für Anfänger zugänglicher zu machen, ohne erfahrene Benutzer zu verwirren. Eines der Dinge, die es tut, ist , mehr Bedeutungen zu gebengit revert . In diesem Fall würden Sie einfach sagen:

eg revert foo/bar foo/baz

Für den Fall, dass Sie eine Datei auf ein vorheriges Commit zurücksetzen möchten (und die Datei, die Sie bereits festgeschrieben zurücksetzen möchten), können Sie verwenden

git checkout HEAD^1 path/to/file

oder

git checkout HEAD~1 path/to/file

Dann einfach inszenieren und die "neue" Version festschreiben.

Mit dem Wissen, dass ein Commit im Falle 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 nur ein Elternteil im Baum vorhanden ist.

Viele Vorschläge hier, meistens in Anlehnung an git checkout $revision -- $file. Ein paar obskure Alternativen:

git show $revision:$file > $file

Außerdem benutze ich dies häufig, um vorübergehend eine bestimmte Version zu sehen:

git show $revision:$file

oder

git show $revision:$file | vim -R -

(OBS: $filemuss vorangestellt werden, ./wenn es sich um einen relativen git show $revision:$fileArbeitspfad handelt)

Und umso seltsamer:

git archive $revision $file | tar -x0 > $file

Beachten Sie jedoch, dass git checkout ./foound git checkout HEAD ./foo nicht genau dasselbe sind; Beispiel:

$ 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 addStufe der Datei im Index wird jedoch nicht festgeschrieben.)

Git checkout ./foobedeutet, den Pfad ./foovom Index zurückzusetzen ; Durch das Hinzufügen wird HEADGit angewiesen, diesen Pfad im Index auf seine HEADRevision zurückzusetzen, bevor Sie dies tun.

Für mich schien keine der Antworten wirklich klar zu sein und deshalb möchte ich meine hinzufügen, was super einfach erscheint.

Ich habe ein Commit abc1und danach habe ich mehrere (oder eine Änderung) an einer Datei vorgenommen file.txt.

Sagen Sie jetzt, dass ich etwas in der Datei durcheinander gebracht habe file.txtund zu einem vorherigen Commit zurückkehren möchte abc1.

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 auf die gewünschte Version gebracht

3 . git commit -m "Restored file.txt to version abc1": Dies wird Ihre Umkehrung begehen.

4. git push : Dadurch wird alles auf das Remote-Repository übertragen

Natürlich können Sie zwischen Schritt 2 und 3 git statusverstehen, was los ist. Normalerweise sollte das file.txtbereits hinzugefügte angezeigt werden, weshalb kein a erforderlich ist git add.

1. Git-Datei auf ein bestimmtes Commit zurücksetzen

git checkout Last_Stable_commit_Number -- fileName

2.Git Datei auf einen bestimmten Zweig zurücksetzen

git checkout branchName_Which_Has_stable_Commit fileName

Um zu einer früheren Festschreibungsversion der Datei zu gelangen, rufen Sie die Festschreibungsnummer ab, z. B. 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

Viele Antworten hier behaupten, sie zu verwenden, git reset ... <file>oder git checkout ... <file>wenn Sie dies tun, verlieren Sie alle Änderungen an <file>Commit nach dem Commit, das Sie zurücksetzen möchten.

Wenn Sie Änderungen von einem Commit nur für eine einzelne Datei rückgängig machen möchten, genau wie git revertfür eine Datei (oder eine Teilmenge der Commit-Dateien), empfehle ich, beide git diffund git applyähnliche Elemente zu verwenden (mit <sha>= dem Hash des Commit, 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 rückgängig machen möchten, und dann der Patch erneut angewendet, um diese Änderungen zu löschen.

Natürlich funktioniert es nicht, wenn zurückgesetzte Zeilen durch ein Commit zwischen <sha1>und HEAD(Konflikt) geändert wurden .

Verwenden Sie git logdiese Option , um den Hash-Schlüssel für eine bestimmte Version abzurufen, und verwenden Sie ihn danngit checkout <hashkey>

Hinweis: Vergessen Sie nicht, den Hash vor dem letzten einzugeben. Der letzte Hash zeigt auf Ihre aktuelle Position (HEAD) und ändert nichts.

Offensichtlich muss jemand entweder ein verständliches Buch über Git schreiben oder Git muss in der Dokumentation besser erklärt werden. Angesichts des gleichen Problems habe ich das erraten

cd <working copy>
git revert master

würde das letzte Commit rückgängig machen, das zu tun scheint.

Ian

Sie können dies in 4 Schritten tun:

1. Setzen Sie das gesamte Commit mit der Datei zurück, die Sie speziell zurücksetzen möchten. Dadurch wird ein neues Commit in Ihrem Zweig erstellt
2. Soft-Reset für das Festschreiben - Entfernt das Festschreiben und verschiebt die Änderungen in den Arbeitsbereich
3. Wählen Sie die Dateien aus, um sie zurückzusetzen und festzuschreiben
4. Legen Sie alle anderen Dateien in Ihrem Arbeitsbereich ab

Was Sie in Ihr Terminal eingeben müssen :

1. git revert <commit_hash>
2. git reset HEAD~1
3. git add <file_i_want_to_revert> && git commit -m 'reverting file'
4. git checkout .

Viel Glück

Dies ist ein sehr einfacher Schritt. Checkout-Datei auf die Commit-ID, die wir wollen, hier eine Commit-ID vorher, und dann git Commit-Änderung und fertig.

# git checkout <previous commit_id> <file_name>
# git commit --amend

Das ist sehr praktisch. Wenn wir eine Datei zu einer früheren Festschreibungs-ID am Anfang des Festschreibens bringen möchten, können wir dies problemlos tun.

git revert <hash>

Wird ein bestimmtes Commit zurücksetzen. Es hört sich so an, als ob Sie denken, dass dies git revertnur das letzte Commit betrifft.

Das löst Ihr Problem nicht, wenn Sie eine Änderung in einer bestimmten Datei rückgängig machen möchten und dieses Commit mehr als diese Datei geändert hat.

Wenn Sie bei Ihren letzten Festschreibungen eine falsche Datei festschreiben, befolgen Sie die Anweisungen:

1. Open Source-Baum, ändern Sie zu diesem Commit

2. Ändern Sie die Zeilen und finden Sie Ihr Commit, dass die falsche Datei als Commit gesendet wurde

3. Sie können die Liste Ihrer Änderungen in diesem Commit sehen
4. Wählen Sie es aus und klicken Sie dann auf ... Schaltflächen auf der rechten Seite ... klicken Sie auf Datei umkehren
5. Dann können Sie es auf der Registerkarte "Dateistatus" unten links sehen und dann auf "Unstage" klicken:

6. Öffnen Sie Ihren Visual Studio-Code und kehren Sie zurück, indem Sie die entfernten Dateien festschreiben
7. Schließlich können Sie die Ergebnisse Ihres letzten Commits im Quellbaum sehen