Eine bestimmte Datei mit Git zurücksetzen oder auf eine bestimmte Version zurücksetzen?

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

Wie funktioniert git prevision?

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.

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

1. open Source-Baum, ändern Sie dieses Commit

2. Ändern Sie die Zeilen und stellen Sie fest, 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 rechts ... Klicken Sie auf Datei umkehren
5. dann sehen Sie es auf der Registerkarte Dateistatus unten links Klicken Sie dann auf unstage:

6. Öffnen Sie Ihren visuellen Studio-Code und stellen Sie die entfernten Dateien wieder her
7. danach sehen Sie die Ergebnisse in Ihrem letzten Commit im Quellbaum

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:

1. setzen Sie das gesamte Commit mit der Datei zurück, die Sie speziell zurücksetzen möchten - es wird ein neues Commit für Ihren Zweig erstellt
2. soft reset that commit - entfernt das Commit und verschiebt die Änderungen in den Arbeitsbereich
3. wählen Sie die Dateien manuell aus, um sie zurückzusetzen und zu übergeben
4. alle anderen Dateien in Ihrem Arbeitsbereich ablegen

Was müssen Sie in Ihr Terminal eingeben :

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

1. Git setzt die Datei auf ein bestimmtes Commit zurück

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