Say I'm in a Git repository. I delete a file and commit that change. I continue working and make some more commits. Then, I find I need to restore that file.
I know I can checkout a file using git checkout HEAD^ foo.bar
, but I don't really know when that file was deleted.
I'm hoping I don't have to manually browse my logs, checkout the entire project for a given SHA and then manually copy that file into my original project checkout.
This question is related to
git
file-io
git-checkout
In order to restore all deleted file with Git, you can also do:
git checkout $(git ls-files --deleted)
Where git ls-files --deleted
lists all deleted files and git checkout $(git command)
restores the list of files in a parameter.
To restore all those deleted files in a folder, enter the following command.
git ls-files -d | xargs git checkout --
$ git log --diff-filter=D --summary | grep "delete" | sort
I had the same question. Without knowing it, I had created a dangling commit.
List dangling commits
git fsck --lost-found
Inspect each dangling commit
git reset --hard <commit id>
My files reappeared when I moved to the dangling commit.
git status
for the reason:
“HEAD detached from <commit id where it detached>”
To restore a deleted and commited file:
git reset HEAD some/path
git checkout -- some/path
It was tested on Git version 1.7.5.4.
I've got this solution.
Get the id of the commit where the file was deleted using one of the ways below.
git log --grep=*word*
git log -Sword
git log | grep --context=5 *word*
git log --stat | grep --context=5 *word*
# recommended if you hardly
remember anythingYou should get something like:
commit bfe68bd117e1091c96d2976c99b3bcc8310bebe7 Author: Alexander Orlov Date: Thu May 12 23:44:27 2011 +0200
replaced deprecated GWT class - gwtI18nKeySync.sh, an outdated (?, replaced by a Maven goal) I18n generation script
commit 3ea4e3af253ac6fd1691ff6bb89c964f54802302 Author: Alexander Orlov Date: Thu May 12 22:10:22 2011 +0200
3. Now using the commit id bfe68bd117e1091c96d2976c99b3bcc8310bebe7 do:
git checkout bfe68bd117e1091c96d2976c99b3bcc8310bebe7^1 yourDeletedFile.java
As the commit id references the commit where the file was already deleted you need to reference the commit just before bfe68b which you can do by appending ^1
. This means: give me the commit just before bfe68b.
Find the commit that deleted your file:
git log --diff-filter=D --oneline -- path/to/file | cut -f -d ' '
Sample output:
4711174
As of Git 2.23 there is actually a restore
command. It is still experimental but in order to restore something you removed in a commit (4711174 in this case) you can then type:
git restore --source=4711174^ path/to/file
Note the ^ after the commit id as we want to restore something from the commit before the one that deleted the file.
The --source
argument tells the restore
command where to look for the file(s) to restore and it can be any commit and even the index.
In many cases, it can be useful to use coreutils (grep, sed, etc.) in conjunction with Git. I already know these tools quite well, but Git less so. If I wanted to do a search for a deleted file, I would do the following:
git log --raw | grep -B 30 $'D\t.*deleted_file.c'
When I find the revision/commit:
git checkout <rev>^ -- path/to/refound/deleted_file.c
Just like others have stated before me.
The file will now be restored to the state it had before removal. Remember to re-commit it to the working tree if you want to keep it around.
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
Restore the deleted file:
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
If you know the filename, this is an easy way with basic commands:
List all the commits for that file.
git log -- path/to/file
The last commit (topmost) is the one that deleted the file. So you need to restore the second to last commit.
git checkout {second to last commit} -- path/to/file
I came to this question looking to restore a file I just deleted but I hadn't yet committed the change. Just in case you find yourself in this situation, all you need to do is the following:
git checkout HEAD -- path/to/file.ext
Simple and precise-
First of all, get a latest stable commit in which you have that file by -
git log
Say you find $commitid 1234567..., then
git checkout <$commitid> $fileName
This will restore the file version which was in that commit.
For the best way to do that, try it.
First, find the commit id of the commit that deleted your file. It will give you a summary of commits which deleted files.
git log --diff-filter=D --summary
git checkout 84sdhfddbdddf~1
Note: 84sdhfddbddd
is your commit id
Through this you can easily recover all deleted files.
If you only made changes and deleted a file, but not commit it, and now you broke up with your changes
git checkout -- .
but your deleted files did not return, you simply do the following command:
git checkout <file_path>
And presto, your file is back.
If you know the commit that deleted the file(s), run this command where <SHA1_deletion>
is the commit that deleted the file:
git diff --diff-filter=D --name-only <SHA1_deletion>~1 <SHA1_deletion> | xargs git checkout <SHA1_deletion>~1 --
The part before the pipe lists all the files that were deleted in the commit; they are all checkout from the previous commit to restore them.
Actually, this question is directly about Git, but somebody like me works with GUI tools like the WebStorm VCS other than knowing about Git CLI commands.
I right click on the path that contains the deleted file, and then go to Git and then click on Show History.
The VCS tools show all revisions train and I can see all commits and changes of each of them.
Then I select the commits that my friend delete the PostAd.js
file. now see below:
And now, I can see my desire deleted file. I just double-click on the filename and it recovers.
I know my answer is not Git commands, but it is fast, reliable and easy for beginner and professional developers. WebStorm VCS tools are awesome and perfect for working with Git and it doesn't need any other plugin or tools.
I had to restore a bunch of deleted files from a specific commit, and I managed it with two commands:
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
(Note the trailing space on the end of each command.)
The files had been added to the .gitignore file and then cleared with git rm
. I needed to restore the files, but then unstage them. I had hundreds of files to restore, and typing things manually for each file as in the other examples was going to be far too slow.
My new favorite alias, based on bonyiii's answer (upvoted), and my own answer about "Pass an argument to a Git alias command":
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'
I have lost a file, deleted by mistake a few commits ago?
Quick:
git restore my_deleted_file
Crisis averted.
Warning, with Git 2.23 (Q3 2019) comes the experimental command named git restore
(!).
So rename this alias (as shown below).
Robert Dailey proposes in the comments the following alias:
restore-file = !git checkout $(git rev-list -n 1 HEAD -- "$1")^ -- "$1"
And jegan adds in the comments:
For setting the alias from the command line, I used this command:
git config --global alias.restore "\!git checkout \$(git rev-list -n 1 HEAD -- \"\$1\")^ -- \"\$1\""
You could always git revert
your commit which deleted the file. (This assumes that the deletion was the only change in the commit.)
> git log
commit 2994bda49cd97ce49099953fc3f76f7d3c35d1d3
Author: Dave <[email protected]>
Date: Thu May 9 11:11:06 2019 -0700
deleted readme.md
And if you've continued work, and realized later that you didn't want to commit that deletion commit, you could revert it using:
> git revert 2994bd
Now git log
shows:
> git log
Author: Dave <[email protected]>
Date: Thu May 9 11:17:41 2019 -0700
Revert "deleted readme"
This reverts commit 2994bda49cd97ce49099953fc3f76f7d3c35d1d3.
And readme.md
has been restored into the repository.
git log --diff-filter=D --summary
to get all the commits which have deleted files and the files deleted;git checkout $commit~1 path/to/file.ext
to restore the deleted file.Where $commit
is the value of the commit you've found at step 1, e.g. e4cf499627
If the deletion has not been committed, the command below will restore the deleted file in the working tree.
$ git checkout -- <file>
You can get a list of all the deleted files in the working tree using the command below.
$ git ls-files --deleted
If the deletion has been committed, find the commit where it happened, then recover the file from this commit.
$ git rev-list -n 1 HEAD -- <file>
$ git checkout <commit>^ -- <file>
In case you are looking for the path of the file to recover, the following command will display a summary of all deleted files.
$ git log --diff-filter=D --summary
If you’re insane, use git-bisect
. Here's what to do:
git bisect start
git bisect bad
git bisect good <some commit where you know the file existed>
Now it's time to run the automated test. The shell command '[ -e foo.bar ]'
will return 0 if foo.bar
exists, and 1 otherwise. The "run" command of git-bisect
will use binary search to automatically find the first commit where the test fails. It starts halfway through the range given (from good to bad) and cuts it in half based on the result of the specified test.
git bisect run '[ -e foo.bar ]'
Now you're at the commit which deleted it. From here, you can jump back to the future and use git-revert
to undo the change,
git bisect reset
git revert <the offending commit>
or you could go back one commit and manually inspect the damage:
git checkout HEAD^
cp foo.bar /tmp
git bisect reset
cp /tmp/foo.bar .
In our case we accidentally deleted files in a commit and some commits later we realized our mistake and wanted to get back all the files that were deleted, but not those that were modified.
Based on Charles Bailey's excellent answer, here is my one-liner:
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)
git undelete path/to/file.ext
Put this in your .bash_profile
(or other relevant file that loads when you open a command shell):
git config --global alias.undelete '!sh -c "git checkout $(git rev-list -n 1 HEAD -- $1)^ -- $1" -'
Then use:
git undelete path/to/file.ext
This alias first checks to find the last commit where this file existed, and then does a Git checkout of that file path from that last commit where this file existed. Source.
I also have this problem using the below code to retrieve a previous file to a local directory:
git checkout <file path with name>
The below example is working for me:
git checkout resources/views/usaSchools.blade.php
git checkout /path/to/deleted.file
Source: Stackoverflow.com