How do I revert all local changes in Git managed project to previous state?

Asked 2023-09-20 20:28:16 View 589,494

I ran git status which told me everything was up to date and there were no local changes.

Then I made several consecutive changes and realized I wanted to throw everything away and get back to my original state. Will this command do it for me?

git reset --hard HEAD

Answers

To revert changes made to your working copy, do this:

git checkout .

Or equivalently, for git version >= 2.23:

git restore .

To revert changes made to the index (i.e., that you have added), do this. Warning this will reset all of your unpushed commits to master!:

git reset

To revert a change that you have committed:

git revert <commit 1> <commit 2>

To remove untracked files (e.g., new files, generated files):

git clean -f

Or untracked directories (e.g., new or automatically generated directories):

git clean -fd

Answered   2023-09-20 20:28:16

  • fwiw after such a long time, git checkout path/to/file will only revert the local changes to path/to/file - anyone
  • +1 on the answers below also mentioning git clean -f (to remove the untracked changes) and -fd (to also remove untracked directories) - anyone
  • git checkout . and git reset [--hard HEAD] didn't work, I had to do a git clean -fd to revert my changes. - anyone
  • git reset doesn't reset your changes, git reset --hard does that. - anyone
  • The warning is totally wrong! First of all, git reset works on the current branch (HEAD) and what it does has nothing to do with the "master" branch. Also, reset has nothing to do with unpushed commits and no you don't automatically lose them just because you used git reset. - anyone

Note: You may also want to run

git clean -fd

as

git reset --hard

will not remove untracked files, where as git-clean will remove any files from the tracked root directory that are not under git tracking. WARNING - BE CAREFUL WITH THIS! It is helpful to run a dry-run with git-clean first, to see what it will delete.

This is also especially useful when you get the error message

~"performing this command will cause an un-tracked file to be overwritten"

Which can occur when doing several things, one being updating a working copy when you and your friend have both added a new file of the same name, but he's committed it into source control first, and you don't care about deleting your untracked copy.

In this situation, doing a dry run will also help show you a list of files that would be overwritten.

Answered   2023-09-20 20:28:16

  • The file clean command is "git clean -f". Untracked directories are removed with "git clean -d" - anyone
  • git clean -fd (force is required for -d) - anyone
  • -n or --dry-run are the flags for dry-run. - anyone
  • git clean -ffd if you have another git repository in your git repository. Without double f it would not be removed. - anyone

Re-clone

GIT=$(git rev-parse --show-toplevel)
cd $GIT/..
rm -rf $GIT
git clone ...
  • ✅ Deletes local, non-pushed commits
  • ✅ Reverts changes you made to tracked files
  • ✅ Restores tracked files you deleted
  • ✅ Deletes files/dirs listed in .gitignore (like build files)
  • ✅ Deletes files/dirs that are not tracked and not in .gitignore
  • 😀 You won't forget this approach
  • 😔 Wastes bandwidth

Following are other commands I forget daily.

Clean and reset

git clean --force -d -x
git reset --hard
  • ❌ Deletes local, non-pushed commits
  • ✅ Reverts changes you made to tracked files
  • ✅ Restores tracked files you deleted
  • ✅ Deletes files/dirs listed in .gitignore (like build files)
  • ✅ Deletes files/dirs that are not tracked and not in .gitignore

Clean

git clean --force -d -x
  • ❌ Deletes local, non-pushed commits
  • ❌ Reverts changes you made to tracked files
  • ❌ Restores tracked files you deleted
  • ✅ Deletes files/dirs listed in .gitignore (like build files)
  • ✅ Deletes files/dirs that are not tracked and not in .gitignore

Reset

git reset --hard
  • ❌ Deletes local, non-pushed commits
  • ✅ Reverts changes you made to tracked files
  • ✅ Restores tracked files you deleted
  • ❌ Deletes files/dirs listed in .gitignore (like build files)
  • ❌ Deletes files/dirs that are not tracked and not in .gitignore

Notes

Test case for confirming all the above (use bash or sh):

mkdir project
cd project
git init
echo '*.built' > .gitignore
echo 'CODE' > a.sourceCode
mkdir b
echo 'CODE' > b/b.sourceCode
cp -r b c
git add .
git commit -m 'Initial checkin'
echo 'NEW FEATURE' >> a.sourceCode
cp a.sourceCode a.built
rm -rf c
echo 'CODE' > 'd.sourceCode'

See also

  • git revert to make new commits that undo prior commits
  • git checkout to go back in time to prior commits (may require running above commands first)
  • git stash same as git reset above, but you can undo it

Answered   2023-09-20 20:28:16

  • I'm pretty sure, that the first option (Re-clone) actually DOES "delete local, non-pushed commits" :) - anyone
  • @styfle ✅ is something it does, ❌ is something it doesn't do - anyone
  • @FullDecent It's kind of confusing to read. "❌ Does NOT delete local, non-pushed commits". That means it doesn't NOT delete. The double negative means that it does delete? - anyone
  • Thank you, double negatives corrected, because a single negative is MORE negative - anyone
  • About -x flag in git clean -f -d -x: if the -x option is specified, ignored files are also removed. This can, for example, be useful to remove all build products.- from GIT docs - anyone

If you want to revert all changes AND be up-to-date with the current remote master (for example you find that the master HEAD has moved forward since you branched off it and your push is being 'rejected') you can use

git fetch  # will fetch the latest changes on the remote
git reset --hard origin/master # will set your local branch to match the representation of the remote just pulled down.

Answered   2023-09-20 20:28:16

  • It seems important to specify origin in git reset --hard origin/master (which works) – without it (i.e. git reset --hard) nothing seems to be changed. - anyone
  • I had some local changes and not able to get rid of them by any command I did git reset --hard origin/master and it was able to pull master's changes as well - anyone

After reading a bunch of answers and trying them, I've found various edge cases that mean sometimes they don't fully clean the working copy.

Here's my current bash script for doing it, which works all the time.

#!/bin/sh
git reset --hard
git clean -f -d
git checkout HEAD

Run from working copy root directory.

Answered   2023-09-20 20:28:16

  • Last command gives me error: pathspec 'HEAD' did not match any file(s) known to git. - anyone
  • It worked for me when I took the "--" out. git checkout HEAD - anyone
  • git reset --hard reverts tracked files (staged or not), git clean -f -d removes untracked files, git checkout -- HEAD why do we need this then? - anyone
  • We dont need the double hyphen. Must be a typo. - anyone
  • Removed -- in git checkout -- HEAD as this is not a valid command, while git checkout HEAD is. - anyone

Look into git-reflog. It will list all the states it remembers (default is 30 days), and you can simply checkout the one you want. For example:

$ git init > /dev/null
$ touch a
$ git add .
$ git commit -m"Add file a" > /dev/null
$ echo 'foo' >> a
$ git commit -a -m"Append foo to a" > /dev/null
$ for i in b c d e; do echo $i >>a; git commit -a -m"Append $i to a" ;done > /dev/null
$ git reset --hard HEAD^^ > /dev/null
$ cat a
foo
b
c
$ git reflog
145c322 HEAD@{0}: HEAD^^: updating HEAD
ae7c2b3 HEAD@{1}: commit: Append e to a
fdf2c5e HEAD@{2}: commit: Append d to a
145c322 HEAD@{3}: commit: Append c to a
363e22a HEAD@{4}: commit: Append b to a
fa26c43 HEAD@{5}: commit: Append foo to a
0a392a5 HEAD@{6}: commit (initial): Add file a
$ git reset --hard HEAD@{2}
HEAD is now at fdf2c5e Append d to a
$ cat a
foo
b
c
d

Answered   2023-09-20 20:28:16

  • thanks a ton William, for git reflog. I reset my tree to old version and not sure how to retrive to recent. your git reflog saved me. Thanks once again. - anyone
  • saved me as well! In my case my adventure with git rebase -i had gone wrong (ended up wiping out some commits due to an editing mistake). Thanks to this tip I'm back in a good state! - anyone
  • What do you mean by 30 days default !? - anyone
  • @MoheTheDreamy I mean that there is a time limit. Eventually the garbage collector will delete unreachable references when their age goes over that limit. The default used to be (and maybe still is) 30 days. So older references may not be available. - anyone

simply execute -

git stash

it will remove all your local changes. and you can also use it later by executing -

git stash apply 

Answered   2023-09-20 20:28:16

  • use git stash pop would automatically remove topmost the stashed change for you - anyone
  • git stash drop to remove the latest stashed state without apply to working copy. - anyone
  • git stash apply wont add newly created files - anyone

DANGER AHEAD: (please read the comments. Executing the command proposed in my answer might delete more than you want)

to completely remove all files including directories I had to run

git clean -f -d

Answered   2023-09-20 20:28:16

  • To save anyone the pain I just went through: this will delete .gitignore-d files too! - anyone
  • sorry if I caused you any trouble. Back then I just tried to revert and delete everything in that folder. I don't recall the exact circumstances, but the "-d" was the only thing working for me. I hope I did not cause you too much pain :-) - anyone
  • no harm done. I had backups, but this probably warrants a disclaimer ;) - anyone

Try this if you are in top project directory:

git restore .

If not then use:

git restore :/

If you would like to revert local changes for a subset:

  • restore all working tree files with top pathspec magic: git restore :/
  • restore all files in the current directory: git restore .
  • file type (e.g. all C source files): git restore '*.c'

For details see git restore documentation.

To remove untracked files: git clean -f

Answered   2023-09-20 20:28:16

  • Thanks for this. That "magic" is an abomination, though. Why not support a wildcard? - anyone
  • SO post on pathspec for those wondering. @pdoherty926 pathspec also has wildcards included in its syntax; not sure how well though. - anyone

I met a similar problem. The solution is to use git log to look up which version of the local commit is different from the remote. (E.g. the version is 3c74a11530697214cbcc4b7b98bf7a65952a34ec).

Then use git reset --hard 3c74a11530697214cbcc4b7b98bf7a65952a34ec to revert the change.

Answered   2023-09-20 20:28:16

I searched for a similar issue,

Wanted to throw away local commits:

  1. cloned the repository (git clone)
  2. switched to dev branch (git checkout dev)
  3. did few commits (git commit -m "commit 1")
  4. but decided to throw away these local commits to go back to remote (origin/dev)

So did the below:

git reset --hard origin/dev

Check:

git status  

        On branch dev  
        Your branch is up-to-date with 'origin/dev'.  
        nothing to commit, working tree clean  

now local commits are lost, back to the initial cloned state, point 1 above.

Answered   2023-09-20 20:28:16

  • thanks, that's the only thing that worked for me - "git reset --hard origin" - anyone

The other answers seemed way too complicated, so here is a simple solution that worked for me:

How to discard all local changes and reset the files to the last commit on my current branch?

# Execute on the root of the working tree...

# Discard all changes to tracked files
git checkout .

# Remove all untracked files 
git clean -fd

Note: ignored files will remain unaffected

Answered   2023-09-20 20:28:16

  • Far and away the best answer here. Thanks. - anyone

Try this for revert all changes uncommited in local branch

$ git reset --hard HEAD

But if you see a error like this:

fatal: Unable to create '/directory/for/your/project/.git/index.lock': File exists.

You can navigate to '.git' folder then delete index.lock file:

$ cd /directory/for/your/project/.git/
$ rm index.lock

Finaly, run again the command:

$ git reset --hard HEAD

Answered   2023-09-20 20:28:16

Two simple steps

git fetch origin
git reset --hard origin/master

or if your git uses main instead master use this:

git reset --hard origin/main

Answered   2023-09-20 20:28:16

Adding another option here.

I'm referring to the title: Revert local changes.
It can also apply to changes that weren't staged for commit.

In this case you can use:

git restore <file>

To go back to previous state.

Answered   2023-09-20 20:28:16

  • To restore all file changes in a current local directory you can use: git restore . - anyone
  • The best answer out here - anyone
  • Please run git help - you should see it there..(: - anyone

You may not necessarily want/need to stash your work/files in your working directory but instead simply get rid of them completely. The command git clean will do this for you.

Some common use cases for doing this would be to remove cruft that has been generated by merges or external tools or remove other files so that you can run a clean build.

Keep in mind you will want to be very cautious of this command, since its designed to remove files from your local working directory that are NOT TRACKED. if you suddenly change your mind after executing this command, there is no going back to see the content of the files that were removed. An alternative which is safer is to execute

git stash --all

which will remove everything but save it all in a stash. This stash can then later be used.

However, if you truly DO want to remove all the files and clean your working directory, you should execute

git clean -f -d

This will remove any files and also any sub-directories that don't have any items as a result of the command. A smart thing to do before executing the git clean -f -d command is to run

git clean -f -d -n

which will show you a preview of what WILL be removed after executing git clean -f -d

So here is a summary of your options from most aggressive to least aggressive


Option 1: Remove all files locally(Most aggressive)

git clean -f -d

Option 2: Preview the above impact(Preview most aggressive)

git clean -f -d -n

Option 3: Stash all files (Least aggressive)

git stash --all

Answered   2023-09-20 20:28:16

  • I believe this answer is basically wrong. clean -fd deals with new files, but doesn't revert modifications. - anyone

If you just want to delete all the changes, go for git checkout . It's the faster and simpler one.

Answered   2023-09-20 20:28:16

This question is more about broader repository reset / revert, but in case if you're interested in reverting individual change - I've added similar answer in here:

https://stackoverflow.com/a/60890371/2338477

Answers to questions:

  • How to revert individual change with or without change preserving in git history

  • How to return back to old version to restart from same state

Answered   2023-09-20 20:28:16

Using git version "2.37.1"

I reverted all my local changes ( not yet committed ) to previous state ( prior to my local changes ) by using the following command :

git checkout -p

Documentation snippet :

you can use git checkout -p to selectively discard edits from your current working tree

From man git-checkout

  -p, --patch
       Interactively select hunks in the difference between the <tree-ish>
       (or the index, if unspecified) and the working tree. The chosen
       hunks are then applied in reverse to the working tree (and if a
       <tree-ish> was specified, the index).

       **This means that you can use git checkout -p to selectively discard
       edits from your current working tree.** See the “Interactive Mode”
       section of git-add(1) to learn how to operate the --patch mode.

       Note that this option uses the no overlay mode by default (see also
       --overlay), and currently doesn’t support overlay mode.

Answered   2023-09-20 20:28:16