Angenommen, ich bin in einem Git-Repository. Ich lösche eine Datei und schreibe diese Änderung fest. Ich arbeite weiter und mache weitere Verpflichtungen. Dann muss ich diese Datei wiederherstellen.

Ich weiß, dass ich eine Datei mit auschecken kann git checkout HEAD^ foo.bar, aber ich weiß nicht wirklich, wann diese Datei gelöscht wurde.

1. Was wäre der schnellste Weg, um das Commit zu finden, mit dem ein bestimmter Dateiname gelöscht wurde?
2. Was wäre der einfachste Weg, um diese Datei wieder in meine Arbeitskopie aufzunehmen?

Ich hoffe, ich muss meine Protokolle nicht manuell durchsuchen, das gesamte Projekt für eine bestimmte SHA auschecken und diese Datei dann manuell in meine ursprüngliche Projektkasse kopieren.

Suchen Sie das letzte Commit, das den angegebenen Pfad beeinflusst hat. Da sich die Datei nicht im HEAD-Commit befindet, muss sie durch dieses Commit gelöscht worden sein.

git rev-list -n 1 HEAD -- <file_path>

Überprüfen Sie dann die Version beim Festschreiben zuvor mit dem ^Symbol caret ( ):

git checkout <deleting_commit>^ -- <file_path>

Oder in einem Befehl, ob $filees sich um die betreffende Datei handelt.

git checkout $(git rev-list -n 1 HEAD -- "$file")^ -- "$file"

Wenn Sie zsh verwenden und die Option EXTENDED_GLOB aktiviert haben, funktioniert das Caret-Symbol nicht. Sie können ~1stattdessen verwenden.

git checkout $(git rev-list -n 1 HEAD -- "$file")~1 -- "$file"

1. Verwenden Sie git log --diff-filter=D --summarydiese Option , um alle Commits abzurufen, bei denen Dateien gelöscht und die Dateien gelöscht wurden.
2. Verwenden Sie git checkout $commit~1 path/to/file.extdiese Option , um die gelöschte Datei wiederherzustellen.

Wo $commitist der Wert des Commits, den Sie in Schritt 1 gefunden haben, ze4cf499627

Geben Sie den folgenden Befehl ein, um alle gelöschten Dateien in einem Ordner wiederherzustellen.

git ls-files -d | xargs git checkout --

Ich bin auf diese Frage gekommen, um eine Datei wiederherzustellen, die ich gerade gelöscht habe, aber die Änderung noch nicht übernommen habe. Für den Fall, dass Sie sich in dieser Situation befinden, müssen Sie lediglich Folgendes tun:

git checkout HEAD -- path/to/file.ext

Wenn Sie verrückt sind, verwenden Sie git-bisect. Folgendes ist zu tun:

git bisect start
git bisect bad
git bisect good <some commit where you know the file existed>

Jetzt ist es Zeit, den automatisierten Test durchzuführen. Der Shell-Befehl '[ -e foo.bar ]'gibt 0 zurück, falls foo.barvorhanden, andernfalls 1. Der Befehl "run" von git-bisectverwendet die binäre Suche, um automatisch das erste Commit zu finden, bei dem der Test fehlschlägt. Es beginnt in der Mitte des angegebenen Bereichs (von gut bis schlecht) und halbiert ihn basierend auf dem Ergebnis des angegebenen Tests.

git bisect run '[ -e foo.bar ]'

Jetzt sind Sie beim Commit, das es gelöscht hat. Von hier aus können Sie in die Zukunft zurückspringen und git-revertdie Änderung rückgängig machen.

git bisect reset
git revert <the offending commit>

oder Sie können ein Commit zurückgehen und den Schaden manuell untersuchen:

git checkout HEAD^
cp foo.bar /tmp
git bisect reset
cp /tmp/foo.bar .

Mein neues Lieblings alias, basierend auf bonyiii ‚s Antwort (upvoted) und meine eigene Antwort über‚ Übergeben Sie ein Argument für ein Git - Alias - Befehl ‘:

git config alias.restore '!f() { git checkout $(git rev-list -n 1 HEAD -- $1)~1 -- $(git diff --name-status $(git rev-list -n 1 HEAD -- $1)~1 | grep '^D' | cut -f 2); }; f'

Ich habe eine Datei verloren, die vor einigen Commits versehentlich gelöscht wurde.
Schnell:

git restore my_deleted_file

Krise abgewendet.

Achtung, mit Git 2.23 (Q3 2019) kommt der experimentelle Befehl mit dem Namen git restore(!).
Benennen Sie diesen Alias ​​um (wie unten gezeigt).

Robert Dailey schlägt in den Kommentaren den folgenden Alias ​​vor:

restore-file = !git checkout $(git rev-list -n 1 HEAD -- "$1")^ -- "$1"

Und Jegan fügt in den Kommentaren hinzu :

Zum Festlegen des Alias ​​über die Befehlszeile habe ich diesen Befehl verwendet:

git config --global alias.restore "\!git checkout \$(git rev-list -n 1 HEAD -- \"\$1\")^ -- \"\$1\"" 

Wenn Sie den Dateinamen kennen, ist dies mit einfachen Befehlen ein einfacher Weg:

Listen Sie alle Commits für diese Datei auf.

git log -- path/to/file

Das letzte Commit (oberstes) hat die Datei gelöscht. Sie müssen also das vorletzte Commit wiederherstellen.

git checkout {second to last commit} -- path/to/file

So stellen Sie eine gelöschte und festgeschriebene Datei wieder her:

git reset HEAD some/path
git checkout -- some/path

Es wurde auf Git Version 1.7.5.4 getestet.

Wenn Sie nur Änderungen vorgenommen und eine Datei gelöscht, aber nicht festgeschrieben haben, haben Sie jetzt mit Ihren Änderungen Schluss gemacht

git checkout -- .

Ihre gelöschten Dateien wurden jedoch nicht zurückgegeben. Führen Sie einfach den folgenden Befehl aus:

git checkout <file_path>

Und schon ist Ihre Datei zurück.

Ich habe diese Lösung .

1. Rufen Sie die ID des Commits ab, bei dem die Datei auf eine der folgenden Arten gelöscht wurde.

   • git log --grep=*word*
   • git log -Sword
   • git log | grep --context=5 *word*
   • git log --stat | grep --context=5 *word* # empfohlen, wenn Sie sich kaum an etwas erinnern

2. Sie sollten etwas bekommen wie:

Commit bfe68bd117e1091c96d2976c99b3bcc8310bebe7 Autor: Alexander Orlov Datum: Do 12. Mai 23:44:27 2011 +0200

replaced deprecated GWT class
- gwtI18nKeySync.sh, an outdated (?, replaced by a Maven goal) I18n generation script

Commit 3ea4e3af253ac6fd1691ff6bb89c964f54802302 Autor: Alexander Orlov Datum: Do 12. Mai 22:10:22 2011 +0200

3 . Verwenden Sie jetzt die Festschreibungs-ID bfe68bd117e1091c96d2976c99b3bcc8310bebe7, um:

git checkout bfe68bd117e1091c96d2976c99b3bcc8310bebe7^1 yourDeletedFile.java

Da die Commit-ID auf das Commit verweist, bei dem die Datei bereits gelöscht wurde, müssen Sie kurz vor bfe68b auf das Commit verweisen, was Sie durch Anhängen tun können ^1. Dies bedeutet: Geben Sie mir das Commit kurz vor bfe68b.

git checkout /path/to/deleted.file

git undelete path/to/file.ext

1. Fügen Sie dies in Ihre .bash_profile(oder eine andere relevante Datei ein, die beim Öffnen einer Befehlsshell geladen wird):

   git config --global alias.undelete '!sh -c "git checkout $(git rev-list -n 1 HEAD -- $1)^ -- $1" -'
   

2. Dann benutze:

   git undelete path/to/file.ext
   

Dieser Alias ​​überprüft zuerst, ob das letzte Commit gefunden wurde, in dem diese Datei vorhanden war, und führt dann eine Git-Überprüfung dieses Dateipfads von dem letzten Commit durch, in dem diese Datei vorhanden war. Quelle .

In vielen Fällen kann es nützlich sein, Coreutils (grep, sed usw.) in Verbindung mit Git zu verwenden. Ich kenne diese Tools bereits recht gut, Git weniger. Wenn ich nach einer gelöschten Datei suchen möchte, würde ich Folgendes tun:

git log --raw | grep -B 30 $'D\t.*deleted_file.c'

Wenn ich die Revision / Commit finde:

git checkout <rev>^ -- path/to/refound/deleted_file.c

Genau wie andere vor mir gesagt haben.

Die Datei wird nun in dem Zustand wiederhergestellt, den sie vor dem Entfernen hatte. Denken Sie daran, es erneut in den Arbeitsbaum zu übernehmen, wenn Sie es behalten möchten.

Ich musste eine Reihe gelöschter Dateien aus einem bestimmten Commit wiederherstellen und habe es mit zwei Befehlen verwaltet:

git show <rev> --diff-filter=D --summary --name-only --no-commit-id | xargs git checkout <rev>^ -- 
git show <rev> --diff-filter=D --summary --name-only --no-commit-id | xargs git reset HEAD 

(Beachten Sie das Leerzeichen am Ende jedes Befehls.)

Die Dateien wurden der Gitignore-Datei hinzugefügt und dann mit gelöscht git rm. Ich musste die Dateien wiederherstellen, sie dann aber entfernen. Ich musste Hunderte von Dateien wiederherstellen, und die manuelle Eingabe für jede Datei wie in den anderen Beispielen würde viel zu langsam sein.

Eigentlich geht es bei dieser Frage direkt um Git, aber jemand wie ich arbeitet mit GUI-Tools wie dem WebStorm VCS, außer mit Git CLI-Befehlen.

Ich klicke mit der rechten Maustaste auf den Pfad, der die gelöschte Datei enthält, gehe dann zu Git und klicke dann auf Verlauf anzeigen .

Die VCS-Tools zeigen alle Revisionen an und ich kann alle Commits und Änderungen von jedem von ihnen sehen.

Dann wähle ich die Commits aus, mit denen mein Freund die PostAd.jsDatei löscht . jetzt siehe unten:

Und jetzt kann ich meinen Wunsch gelöschte Datei sehen. Ich doppelklicke einfach auf den Dateinamen und er wird wiederhergestellt.

Ich weiß, dass meine Antwort keine Git-Befehle sind, aber sie ist schnell, zuverlässig und einfach für Anfänger und professionelle Entwickler. WebStorm VCS-Tools sind fantastisch und perfekt für die Arbeit mit Git und es werden keine anderen Plugins oder Tools benötigt.

Ich hatte die gleiche Frage. Ohne es zu wissen, hatte ich ein baumelndes Commit erstellt .

Liste baumelnde Commits

git fsck --lost-found

Überprüfen Sie jedes baumelnde Commit

git reset --hard <commit id>

Meine Dateien wurden wieder angezeigt, als ich zum Dangling Commit wechselte.

git status aus dem Grund:

“HEAD detached from <commit id where it detached>”

user@bsd:~/work/git$ rm slides.tex
user@bsd:~/work/git$ git pull 
Already up-to-date.
user@bsd:~/work/git$ ls slides.tex
ls: slides.tex: No such file or directory

Stellen Sie die gelöschte Datei wieder her:

user@bsd:~/work/git$ git checkout
D       .slides.tex.swp
D       slides.tex
user@bsd:~/work/git$ git checkout slides.tex 
user@bsd:~/work/git$ ls slides.tex
slides.tex

Wenn Sie das Commit kennen, mit dem die Datei (en) gelöscht wurden, führen Sie diesen Befehl aus. Dabei <SHA1_deletion>handelt es sich um das Commit, mit dem die Datei gelöscht wurde:

git diff --diff-filter=D --name-only <SHA1_deletion>~1 <SHA1_deletion> | xargs git checkout <SHA1_deletion>~1 --

Der Teil vor der Pipe listet alle Dateien auf, die im Commit gelöscht wurden. Sie sind alle aus dem vorherigen Commit ausgecheckt, um sie wiederherzustellen.

Suchen Sie das Commit, mit dem Ihre Datei gelöscht wurde:

git log --diff-filter=D --oneline -- path/to/file | cut -f -d ' '

Beispielausgabe:

4711174

Ab Git 2.23 gibt es tatsächlich einen restoreBefehl. Es ist noch experimentell, aber um etwas wiederherzustellen, das Sie in einem Commit entfernt haben (in diesem Fall 4711174), können Sie Folgendes eingeben:

git restore --source=4711174^ path/to/file

Beachten Sie die ^ nach der Commit - ID , wie wir etwas wiederherstellen möchten aus dem Commit vor demjenigen der die Datei gelöscht hat.

Das --sourceArgument teilt dem restoreBefehl mit, wo nach den wiederherzustellenden Dateien gesucht werden soll, und es kann sich um ein beliebiges Commit und sogar um den Index handeln.

Siehe: git-restore doc für git 2.23.0

In unserem Fall haben wir versehentlich Dateien in einem Commit gelöscht und einige Commits später haben wir unseren Fehler erkannt und wollten alle gelöschten Dateien zurückbekommen, aber nicht diejenigen, die geändert wurden.

Basierend auf Charles Baileys hervorragender Antwort ist hier mein Einzeiler:

git co $(git rev-list -n 1 HEAD -- <file_path>)~1 -- $(git diff --name-status $(git rev-list -n 1 HEAD -- <file_path>)~1 head | grep '^D' | cut -f 2)

Einfach und präzise

Holen Sie sich zunächst ein aktuelles stabiles Commit, in dem Sie diese Datei haben, indem Sie -

git log 

Angenommen, Sie finden $ commitid 1234567 ... dann

git checkout <$commitid> $fileName

Dadurch wird die Dateiversion wiederhergestellt, die sich in diesem Commit befand.

Probieren Sie es aus, um den besten Weg zu finden.

Suchen Sie zunächst die Commit-ID des Commits, das Ihre Datei gelöscht hat. Sie erhalten eine Zusammenfassung der Commits, mit denen Dateien gelöscht wurden.

git log --diff-filter = D --summary

git checkout 84sdhfddbdddf ~ 1

Hinweis: 84sdhfddbdddist deincommit id

Auf diese Weise können Sie alle gelöschten Dateien einfach wiederherstellen.

Sie könnten immer git revertIhr Commit, das die Datei gelöscht hat. ( Dies setzt voraus, dass das Löschen die einzige Änderung im Commit war. )

> git log
commit 2994bda49cd97ce49099953fc3f76f7d3c35d1d3
Author: Dave <dave@domain.com>
Date:   Thu May 9 11:11:06 2019 -0700

    deleted readme.md

Wenn Sie die Arbeit fortgesetzt haben und später festgestellt haben, dass Sie dieses Lösch-Commit nicht festschreiben möchten, können Sie es mit folgenden Schritten zurücksetzen:

> git revert 2994bd

Jetzt git logzeigt:

> git log
Author: Dave <dave@domain.com>
Date:   Thu May 9 11:17:41 2019 -0700

    Revert "deleted readme"

    This reverts commit 2994bda49cd97ce49099953fc3f76f7d3c35d1d3.

Und readme.mdwurde im Repository wiederhergestellt.

Ich habe auch dieses Problem mit dem folgenden Code, um eine vorherige Datei in ein lokales Verzeichnis abzurufen:

git checkout <file path with name>

Das folgende Beispiel funktioniert für mich:

git checkout resources/views/usaSchools.blade.php

$ git log --diff-filter=D --summary  | grep "delete" | sort

Wenn das Löschen nicht festgeschrieben wurde, stellt der folgende Befehl die gelöschte Datei im Arbeitsbaum wieder her.

$ git checkout -- <file>

Mit dem folgenden Befehl können Sie eine Liste aller gelöschten Dateien im Arbeitsbaum abrufen.

$ git ls-files --deleted

Wenn das Löschen festgeschrieben wurde, suchen Sie das Festschreiben dort, wo es stattgefunden hat, und stellen Sie die Datei aus diesem Festschreiben wieder her.

$ git rev-list -n 1 HEAD -- <file>
$ git checkout <commit>^ -- <file>

Wenn Sie nach dem Pfad der wiederherzustellenden Datei suchen, zeigt der folgende Befehl eine Zusammenfassung aller gelöschten Dateien an.

$ git log --diff-filter=D --summary

Um alle gelöschten Dateien mit Git wiederherzustellen, haben Sie auch folgende Möglichkeiten:

git checkout $(git ls-files --deleted)

Wobei git ls-files --deletedalle gelöschten Dateien aufgelistet und git checkout $(git command)die Liste der Dateien in einem Parameter wiederhergestellt wird.