I deleted some files.
I did NOT commit yet.
I want to reset my workspace to recover the files.
I did a git checkout ..
But the deleted files are still missing.
And git status shows:
# On branch master # Changes to be committed: # (use "git reset HEAD <file>..." to unstage) # # deleted: cc.properties # deleted: store/README # deleted: store/cc.properties # Why doesn't git checkout . reset the workspace to HEAD?
The output tells you what you need to do. git reset HEAD cc.properties etc.
This will unstage the rm operation. After that, running a git status again will tell you that you need to do a git checkout -- cc.properties to get the file back.
Update: I have this in my config file
$ git config alias.unstage reset HEAD which I usually use to unstage stuff.
git reset HEAD \* and then git checkout -- .
rm -r ./engines - oops. Now git reset engines; git checkout engines.-- is to indicate files. e.g. If you have a branch called foo. git co foo will checkout to the branch. However, git co -- foo will checkout the file named foo.You've staged the deletion so you need to do:
git checkout HEAD cc.properties store/README store/cc.properties git checkout . only checks out from the index where the deletion has already been staged.
Just do git checkout path/to/file-I-want-to-bring-back.txt
error: pathspec 'file.ext' did not match any file(s) known to git.
git status say about it?git checkout HEAD -- file.ext helped to restore it.To recover all unstaged deletions at once, automatically, without specifying each single path:
git ls-files -z -d | xargs -0 git checkout -- To recover all staged deletions at once, automatically, without specifying each single path:
git status | grep 'deleted:' | awk '{print $2}' | xargs git checkout -- 
git status --long | grep 'deleted:' | awk '{print $2}' | xargs git reset HEAD --.
git ls-files -d | sed -e "s/\(.*\)/'\1'/" | xargs git checkout -- will work.if you used
git rm filename to delete a file then
git checkout path/to/filename doesn't work, so in that case
git checkout HEAD^ path/to/filename should work
git checkout HEAD^ path/to/filename worked for me since I hadn't committed the file.
git checkout HEAD path/to/filename might be sufficient. So checkout from last, not previous commit.Since you're doing a git checkout ., it looks like you are trying to restore your branch back to the last commit state.
You can achieve this with a git reset HEAD --hard
Doing this may remove all your latest modifications and unstage your modifications, e.g., you can lose work. It may be what you want, but check out the docs to make sure.
Here are different cases as a reference to help others:
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.
#find the commit hash where it had this file deleted $ git rev-list -n 1 HEAD -- <file> It should give you something like c46e81aa403ecb8a0f7a323a358068345, now use this commit hash with the parent operator (^) like so:
$ git checkout <commit>^ -- <file> Example:
$ git checkout c46e81aa403ecb8a0f7a323a358068345^ -- <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 want to just display the list of files:
git log --diff-filter=D --summary | grep "delete mode" 
git rev-list -n 1 HEAD -- <file> didn't work, maybe because <file> only ever existed on a feature branch. Adding --all helped: git rev-list --all -n 1 HEAD -- <file>Here is the command that helped me on my mac. I tried a few of the other solutions but they did not work for me.
Git version on OSX Mavericks
mac-pro:main chris$ git version git version 1.8.5.2 (Apple Git-48) Command
git checkout HEAD -- path/to/file/file.cc Remember to use the period because it tells git to grab all of the files.
This command will reset the head and unstage all of the changes:
$ git reset HEAD . Then run this to restore all of the files:
$ git checkout . Then doing a git status, you'll get:
$ git status On branch master Your branch is up-to-date with 'origin/master'. 
git checkout HEAD -- client/src/pp_web/index.cljs Use git ls-files to checkout deleted(-d) or modified(-m) files.
git checkout $(git ls-files -d) see How can I restore only the modified files on a git checkout?
Situation: One deleted a file but didn’t commit
If one deleted a file, and immediately realized it was a mistake? This one is easy, just do:
git checkout HEAD <filename> If it is a folder, just do:
git checkout HEAD <foldername>/ Reference: https://www.git-tower.com/learn/git/faq/restoring-deleted-files
Do you can want see this
that goes for cases where you used
git checkout -- . before you commit something.
You may also want to get rid of created files that have not yet been created. And you do not want them. With :
git reset -- . 
git checkout -- . does not help to recover deleted files and is equivalent to what the asker tried: git checkout .. The part which can work is the one you didn't copy: git checkout <file_path>.If you have not committed any changes all you have to do is stash those changes and you will be back to the last working commit.
git stash git stash clear git clean 
Found this post while looking for answers on how to un-delete a file that was deleted in my working directory after a merge from another's branch. No commit was yet made after the merge. Since it was a merge in progress, i could not just add it back using:
$ git reset <commitid#-where-file.cpp-existed> file.cpp I had to do another step in addition to the reset to bring the file back:
$ git checkout -- file.cpp This was the easiest way for me:
git checkout HEAD~1 path/to/myfile.rb I found it here.
Another way that also worked for me:
git reset HEAD path/to/myfile.rb git restore path/to/myfile.rb 
Newer git (mine is 2.27.0) is more friendly and the actual commands are shown during "git status". For example, if you deleted the file tf.c, then
$ git status ... Changes not staged for commit: (use "git add/rm <file>..." to update what will be committed) (use "git restore <file>..." to discard changes in working directory) deleted: tf.c You would use "git restore tf.c" to get it back, as it saz. No more search!
git status tells us how to do it! Never noticed those messages...You can use git-restore to get the files back in one go.
If you have not committed your deletions like this:
➜ learning git:(daily) ✗ git status Changes to be committed: (use "git restore --staged <file>..." to unstage) deleted: feelings/articles/2022/1/assets/20220109_093659_image.png deleted: feelings/articles/2022/1/assets/20220109_094525_image.png deleted: feelings/articles/2022/1/assets/20220109_100231_image.png deleted: feelings/articles/2022/1/assets/20220109_100251_image.png deleted: feelings/articles/2022/1/assets/20220109_100321_image.png deleted: feelings/articles/2022/1/assets/20220109_101009_image.png you can use something like this to recover your files:
git restore --worktree --staged feelings/articles/2022/1/assets -W, --worktree, -S, --staged
Specify the restore location. If neither option is specified, by default the working tree is restored. Specifying --staged will only restore the index. Specifying both restores both.
if you are looking for a deleted directory.
git checkout ./pathToDir/* I happened to move (instead of copy) some json files from one folder to another within the same repository. Then I renamed those files and changed some contents in the new location. However I quickly learned that I have not copied and totally deleted the files from previous location.
Easy Solution:
git reset HEAD <oldfilepath_which_was_moved> git restore <oldfilepath_which_was_moved> Did this for all the files and they are back.
You can also include multiple files separated by space.
git reset HEAD file_1_path file_2_path file_3_path Easy fix, btw this will not change / delete the new files.
git restore <oldfilepath_which_was_moved>. This is the simplest easiest answer here!For me what worked was git checkout {SHA1 of commit with version to restore} "{path to file to restore}"
For example git checkout 5a6b3179e58edff9c90326b9a04284b02fd67bd0 "src-ui/views/includes/radar.pug"
(executed in the branch that we want the file to go into)
After that command executes, the restored file will exist in the original location (which will need to be comited)
git checkout master path/to/the/file.bin so that you just undelete that file without loosing any other change you might have done. PS: this should be the accepted answer...1.Find that particular commit to which you want to revert using:
git log This command will give you a list of commits done by you . 2.Revert to that commit using :
git revert <commit id> Now you local branch would have all files in particular
If you have installed ToroiseGIT then just select "Revert..." menu item for parent folder popup-menu.
CAUTION: commit any work you wish to retain first.
You may reset your workspace (and recover the deleted files)
git checkout ./* 
./*.
./* will be expanded by bash to match those files before being sent to git.I had the same problem however none of the above solutions worked for me. What I ended up doing was:
- create an empty file with the same name
- compare this file with its local history
- copy history across to empty file.
git reset HEAD --hard command will merge pull request from the originator branch ,so you will find the deleted file
I had the same problem and none of the answers here I tried worked for me either. I am using Intellij and I had checked out a new branch git checkout -b minimalExample to create a "minimal example" on the new branch of some issue by deleting a bunch of files and modifying a bunch of others in the project. Unfortunately, even though I didn't commit any of the changes on the new "minimal example" branch, when I checked out my "original" branch again all of the changes and deletions from the "minimal example" branch had happened in the "original" branch too (or so it appeared). According to git status the deleted files were just gone from both branches.
Fortunately, even though Intellij had warned me "deleting these files may not be fully recoverable", I was able to restore them (on the minimal example branch from which they had actually been deleted) by right-clicking on the project and selecting Local History > Show History (and then Restore on the most recent history item I wanted). After Intellij restored the files in the "minimal example" branch, I pushed the branch to origin. Then I switched back to my "original" local branch and ran git pull origin minimalExample to get them back in the "original" branch too.
One solution without any risks is to go to your repository page (on github etc.) and download the deleted file by hand.
For anyone who get unknown revision or path not in the working tree when running git checkout
run git reset fileToRestore
then git checkout fileToRestore
Your file will be restored
