Recover from losing uncommitted changes by "git reset --hard"

Question

Is there any way to recover uncommitted changes to the working directory from a git reset --hard HEAD?

Answer 1

For previously committed changes (answer from this SO):

$ git reflog show

4b6cf8e (HEAD -> master, origin/master, origin/HEAD) HEAD@{0}: reset: moving to origin/master
295f07d HEAD@{1}: pull: Merge made by the 'recursive' strategy.
7c49ec7 HEAD@{2}: commit: restore dependencies to the User model
fa57f59 HEAD@{3}: commit: restore dependencies to the Profile model
3431936 HEAD@{4}: commit (amend): restore admin
033f5c0 HEAD@{5}: commit: restore admin
ecd2c1d HEAD@{6}: commit: re-enable settings app

# assuming you want to get back to 7c49ec7 (restore dependencies to the User model)

$ git reset HEAD@{2}

You got your day back! :)

Answer 2

You cannot get back uncommitted changes in general.

Previously staged changes (git add) should be recoverable from index objects, so if you did, use git fsck --lost-found to locate the objects related to it. (This writes the objects to the .git/lost-found/ directory; from there you can use git show <filename> to see the contents of each file.)

If not, the answer here would be: look at your backup. Perhaps your editor/IDE stores temp copies under /tmp or C:\TEMP and things like that.[1]

git reset HEAD@{1}

This will restore to the previous HEAD

[1] vim e.g. optionally stores persistent undo, eclipse IDE stores local history; such features might save your a**

Answer 3

I accidentally ran git reset --hard on my repo today too while having uncommitted changes too today. To get it back, I ran git fsck --lost-found, which wrote all unreferenced blobs to <path to repo>/.git/lost-found/. Since the files were uncommitted, I found them in the other directory within the <path to repo>/.git/lost-found/. From there, I can see the uncommitted files using git show <filename>, copy out the blobs, and rename them.

Note: This only works if you added the files you want to save to the index (using git add .). If the files weren't in the index, they are lost.

Answer 4

No not uncommitted changes but you can recover previously committed changes after a hard reset in git.

Use:

git reflog

to get the identifier of your commit. Then use:

git reset --hard <commit-id-retrieved-using-reflog>

This trick saved my life a couple of times.

You can find the documentation of reflog HERE.

Answer 5

While I was working on a local project, I wanted to move it to GitHub and then created a new repository. While I was trying to add all these files to the new repository with .gitignore, I accidentally added a wrong file and then tried to clear it.

I ran git reset --hard origin/master

Then all of my local files deleted because the repo was empty. I thought everything was gone.

This worked for me:

git reflog show
git reset HEAD@{1} 
git push 

Answer 6

If you use something like IntelliJ:

On the context menu, choose Local History, and click Show History on the submenu:

The local history view for a project or folder shows you everything that you have done during the last few days. In the Action column of the lower part of the dialog box, select the action you want to roll back. [...] So doing, the upper part of the dialog box shows the tree view of changed files. If you want to restore the deleted file only, regardless of the other changes that have been done since then, you can select the file Lost.txt in the tree view and click the Revert button.

http://blog.jetbrains.com/idea/2008/01/using-local-history-to-restore-deleted-files/

This just got my arse out the fire!

Answer 7

I just did git reset --hard and lost all my uncommitted changes. Luckily, I use an editor (IntelliJ) and I was able to recover the changes from the Local History. Eclipse should allow you to do the same.

Answer 8

By definition, git reset --hard will throw away uncommitted changes without any way for Git to recover them (your backup system may help, but not Git).

Actually, there are very few cases where git reset --hard is a good idea. In most cases, there's a safer command to do the same thing:

• If you want to throw away your uncommitted changes, then use git stash. It will keep a backup of these changes, which will expire after some time if you run git gc. If you're 99.9% sure you'll never need these changes back, then git stash is still your friend for the 0.1% case. If you're 100% sure, then git stash is still your friend because these 100% have a measurement error ;-).

• If you want to move your HEAD and the tip of the current branch in history, then git reset --keep is your friend. It will do the same thing as git reset --hard, but will not discard your local changes.

• If you want to do both, then git stash && git reset --keep is your friend.

Teach your fingers not to use git reset --hard, it will pay back one day.

Answer 9

This is what I usually do if I lose some changes.

git reflog
git checkout <commit id> // now you are in where you want but you cannot push from detached branch to master
manually copy and paste changes from detached branch to master or working branch
git reset --hard HEAD // if needed
git add ... > git commit ... > git push ...

to move the pointer back to your previous commits but keeping the changes you made so far in your latest commits checkout git reset --soft dadada

Answer 10

IntelliJ has a temporary folder accessible through the history command:

1. Select the folder to revert files from in your navigation pane
2. Double tap the Shift key (shift-shift)
3. In the input box that pops up type Local History and press Enter
4. Select Show History
5. Now you can revert to the version you need.

Answer 11

I ran into same issue and I was almost going insane....initially I committed the project and merged. Later when I try running git push --set-upstream origin master I was getting this error

  fatal: refusing to merge unrelated histories

so I ran git reset --hard HEAD and it deleted a 3 weeks project but these few commands below save the day:

git reset HEAD@{1}         //this command unstage changes after reset
git fsck --lost-found      //I got the dangling commit fc3b6bee2bca5d8a7e16b6adaca6a76e620eca4b
git show <dangling commit something like-> fc3b6bee2bca5d8a7e16b6adaca6a76e620eca4b>
git rebase fc3b6bee2bca5d8a7e16b6adaca6a76e620eca4b

Answer 12

The information is lost.

Since you did not commit, your .git never stored this information. So, basically git cannot recover it for you.

But, If you just did git diff, there is a way you can recover using the terminal output with the following 3 simple steps.

1. scroll your terminal and look for the o/p of git diff. Save the o/p in a file called diff.patch
2. Search & Replace all 7 spaces and 8 spaces with tab(\t) character and save the changes.
3. Go into your git repository. Apply the diff.patch (patch -p1 < diff.patch)

Note: While you are copying the data from terminal to a file, be careful and clearly see that the data is continuous output and did not contain any redundant data(due to pressing up and down arrows). Otherwise you might mess it up.

Answer 13

If you luckily had the same files opened on another editor (eg. Sublime Text) try a ctrl-z on those. It just saved me..

Answer 14

I found out the hard way that any uncommitted files before a git reset --hard <commit> gets removed from git history. However, I was lucky enough to have kept my code editor session open during the entire time I was pulling my hair out, that I discovered that a simple control + z in each of the affected files returned the state of the file back to the version before Git so obligingly reset everything I didn't ask it to specifically. Hooray!!

Answer 15

(answer suitable for a subset of users)

If you're on (any recent) macOS, and even if you're away from your Time Machine disk, the OS will have saved hourly backups, called local snapshots.

Enter Time Machine and navigate to the file you lost. The OS will then ask you:

The location to which you're restoring "file.ext" already contains an
item with the same name. Do you want to replace it with the one you're
restoring?

You should be able to recover the file(s) you lost.

Answer 16

For VSCode users whom lost unstaged & uncommitted changes

This will only work if you didn’t extensively edit your files again after reset.

tl;dr Try undoing the file changes in VSCode

I did git reset —-hard when my stakeholders decided to de-scope a feature while I was building it. The same stakeholders changed their minds an hour later.

I took a break and came back. After I saw they changed their minds, I then decided to try and undo the files I was working on and it worked! I managed to get back all my work.

Answer 17

If you're developing on Netbeans, look between the file tabs and the file edit area. There is a "Source" and "History". On "History" you'll see changes made using version control (git/other), but also changes made locally. In this case, local changes could save you.

Answer 18

You can only recover staged (git add) changes that you have lost.

you can recover easily by running this command

step:1 Go to project root directory and then run this command

npx git-recover

step:2 enter recovery directory path like

/Users/apple/RecoveryDirectory

you will get lost file in RecoveryDirectory

Answer 19

I encountered a scenario where I checked out my local changes without committing or stashing them. No command could help me, as much as I know. The thing that worked for me was CTRL+Z.

CTRL + Z

By chance all of my file were open in editor so in the editor I just press CTRL+Z on required files, this solved my problem

PS: I was using Sublime text editor.

Answer 20

Well, the best solution as far as i know is to use the IDE features.

• select the repository where you lost the files and right click on it
• find for Local history in menu > show history
• Now check in version version you all files exist > select that and click on revert. That's all for most possible case.

NOTE: Above solution will work when you were doing change or having repository imported in any IDE eg intelliJ.

Answer 21

If you don't want to do a hard reset, you can recover the lost commit as a new branch...

First:

git reflog

Find the commit you want to recover. It will likely be right at the top if you just made the commit before losing it. Though you may need to scroll further down to find it (press Enter or PageDown). Take note of the HEAD number, and replace 57:

git checkout HEAD@{57}

Create a new branch with the recovered commit:

git checkout -b recovery_branch

You could then cherry pick the commit into your dev branch or do whatever you like with it.

Answer 22

Here is the way that worked for me in IntellijIDEA when I did a hard reset and had uncommited changes:

1. Right-click to select the package in which you want to restore file.
2. Choose Local History -> Show History.
3. Select a change and revert or create a patch.

Answer 23

For later you can use VSCode with ext: GitLens - Git supercharged so you can reverse your code with this extensions