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
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
git reset reverts your commits to master! (It wasn't clear enough for me that added would include committed, and I have accidentally lost my changes) –
Psittacine git checkout . and git reset [--hard HEAD] didn't work, I had to do a git clean -fd to revert my changes. –
Grimaldi git clean as well –
Tabriz git reset doesn't reset your changes, git reset --hard does that. –
Sybyl git reset acts as git reset --mixed ("Resets the index but not the working tree (i.e., the changed files are preserved but not marked for commit) and reports what has not been updated. This is the default action.") which is what I said. git-scm.com/docs/git-reset –
Tabriz git checkout . in the root dir of your project. Or in the subdir that you want to revert. –
Remanent git checkout . in the root of my project only applied to the files in that dir, I had to do git checkout * to revert all sub-directories too. –
Veery --hard. In fact, sometimes that's not right... to do. You might have more luck with the --gentle command. –
Arni git reset is misleading at best and false at worst. It makes the impression that reset will somehow revert your current branch to the master branch, which is totally wrong. reset does not operate on branches, so whatever it does refers to your current branch, even if it's not master. Second, it does not change the working tree, therefore you cannot lose data with reset. If you have unpushed commits, then the commits will disappear from the local history, but the actual files will not be changed. You can commit the same thing again! –
Plasticity git restore . only for change in current dir git restore :/ for all changes in the repository –
Fascinating 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.
GIT=$(git rev-parse --show-toplevel)
cd $GIT/..
rm -rf $GIT
git clone ...
.gitignore (like build files).gitignoreFollowing are other commands I forget daily.
git clean --force -d -x
git reset --hard
.gitignore (like build files).gitignoregit clean --force -d -x
.gitignore (like build files).gitignoregit reset --hard
.gitignore (like build files).gitignoreTest 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 commitsgit 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 itgit 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 –
Hinayana git reset --hard and it restored my tracked files but did NOT delete untracked files. in fact, when i ran git status after, it said Untracked files: (use "git add <file>..." to include in what will be committed). which is what i wanted! why do you say it deletes untracked files, though? –
Ester git clone ... does not work as it is, you need to replace ... with your repository url or use your own custom clone command. –
Radiance 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.
origin in git reset --hard origin/master (which works) – without it (i.e. git reset --hard) nothing seems to be changed. –
Redness git reset --hard without anything else worked for me; perhaps because there were no commits/checkouts/branches, but simply a single modified file? –
Dubious 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.
error: pathspec 'HEAD' did not match any file(s) known to git. –
Eupatrid git checkout HEAD –
Grafton 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? –
Cynar -- in git checkout -- HEAD as this is not a valid command, while git checkout HEAD is. –
Underslung 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
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! –
Hyetography simply execute -
git stash
it will remove all your local changes. and you can also use it later by executing -
git stash apply
git stash pop would automatically remove topmost the stashed change for you –
Yemen git stash drop to remove the latest stashed state without apply to working copy. –
Mitrailleuse 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
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:
git restore :/git restore .git restore '*.c'For details see git restore documentation.
To remove untracked files: git clean -f
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.
I searched for a similar issue,
Wanted to throw away local commits:
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.
The other answers seemed way too complicated, so here is a simple solution that worked for me:
# 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
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
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
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.
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
clean -fd deals with new files, but doesn't revert modifications. –
Ski If you just want to delete all the changes, go for git checkout .
It's the faster and simpler one.
It's a headache, you can try:
git stash --all
git stash apply
This will discard all local changes from the history and keep the files inside the folder.
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://mcmap.net/q/11765/-contaminated-remote-master-branch-or-anti-cherry-pick
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
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.
The multitude of answers here, including the accepted answer, always leaves me questioning which commands I should run.
Many have warnings, and despite visiting this question many times, I can never remember which combination I should, or more importantly should not, run.
So, I am leaving this here for myself when I revisit the topic next week.
git restore .
git clean -f
git clean -fd
For most scenarios you can simply combine the commands, but as I point out in my explanation some cases require you delete files first, then the directories that hold them.
git restore . && git clean -fd
Explanation:
The command git restore . performs a checkout on the current branch to the current directory. This will undo any changes made to any files. More specifically, the command will revert all changes in tracked files to their last committed state in the current directory and subdirectories.
The command git clean -f removes any newly added (untracked) files since the restore. This command permanently deletes files and cannot be undone.
The command git clean -fd removes any newly added directories since the restore. This command permanently deletes directories and their files and cannot be undone.
Note: I am not a git expert, just someone who uses git professionally, every day, all day, for many years. I advise you to consult the documenation.
With that said -fd should take care of -f but there are exceptions where it blows up. In my experience, executing all three commands works. It is kind of like calling Directory.Delete(path, recursive=true) which should delete all files but sometimes for whatever reason (depending on your OS) you must delete each file first before deleting the directory.
Another Note: Misleading Warning in Accepted Answer And Other Answers: The accepted answer's warning regarding git reset ("Warning this will reset all of your unpushed commits to master!") might be misleading. git reset without any arguments defaults to git reset --mixed HEAD, which only affects the staging area (index) and not the working tree or commit history. git reset does not revert commits or affect the branch history unless combined with a commit reference (like git reset --hard <commit>), which indeed can change the commit history in the local repository.
© 2022 - 2024 — McMap. All rights reserved.
git checkout path/to/filewill only revert the local changes topath/to/file– Papp