version control - How do I undo the most recent local commits in Git?

ID : 2

viewed : 638

Tags : gitversion-controlgit-commitundogit

Top 5 Answer for version control - How do I undo the most recent local commits in Git?

vote vote


Undo a commit & redo

$ git commit -m "Something terribly misguided" # (0: Your Accident) $ git reset HEAD~                              # (1) [ edit files as necessary ]                    # (2) $ git add .                                    # (3) $ git commit -c ORIG_HEAD                      # (4) 
  1. This command is responsible for the undo. It will undo your last commit while leaving your working tree (the state of your files on disk) untouched. You'll need to add them again before you can commit them again).

  2. Make corrections to working tree files.

  3. git add anything that you want to include in your new commit.

  4. Commit the changes, reusing the old commit message. reset copied the old head to .git/ORIG_HEAD; commit with -c ORIG_HEAD will open an editor, which initially contains the log message from the old commit and allows you to edit it. If you do not need to edit the message, you could use the -C option.

Alternatively, to edit the previous commit (or just its commit message), commit --amend will add changes within the current index to the previous commit.

To remove (not revert) a commit that has been pushed to the server, rewriting history with git push origin master --force is necessary.

Further Reading

How can I move HEAD back to a previous location? (Detached head) & Undo commits

The above answer will show you git reflog, which you can use to determine the SHA-1 for the commit to which you wish to revert. Once you have this value, use the sequence of commands as explained above.

HEAD~ is the same as HEAD~1. The article What is the HEAD in git? is helpful if you want to uncommit multiple commits.

vote vote


Undoing a commit is a little scary if you don't know how it works. But it's actually amazingly easy if you do understand. I'll show you the 4 different ways you can undo a commit.

option 1: git reset --hard

Say you have this, where C is your HEAD and (F) is the state of your files.

   (F) A-B-C     ↑   master 

You want to nuke commit C and never see it again and lose all the changes in locally modified files. You do this:

git reset --hard HEAD~1 

The result is:

 (F) A-B   ↑ master 

Now B is the HEAD. Because you used --hard, your files are reset to their state at commit B.

option 2: git reset

Ah, but suppose commit C wasn't a disaster, but just a bit off. You want to undo the commit but keep your changes for a bit of editing before you do a better commit. Starting again from here, with C as your HEAD:

   (F) A-B-C     ↑   master 

You can do this, leaving off the --hard:

git reset HEAD~1 

In this case the result is:

   (F) A-B-C   ↑ master 

In both cases, HEAD is just a pointer to the latest commit. When you do a git reset HEAD~1, you tell Git to move the HEAD pointer back one commit. But (unless you use --hard) you leave your files as they were. So now git status shows the changes you had checked into C. You haven't lost a thing!

option 3: git reset --soft

For the lightest touch, you can even undo your commit but leave your files and your index:

git reset --soft HEAD~1 

This not only leaves your files alone, it even leaves your index alone. When you do git status, you'll see that the same files are in the index as before. In fact, right after this command, you could do git commit and you'd be redoing the same commit you just had.

option 4: you did git reset --hard and need to get that code back

One more thing: Suppose you destroy a commit as in the first example, but then discover you needed it after all? Tough luck, right?

Nope, there's still a way to get it back. Type git reflog and you'll see a list of (partial) commit shas (that is, hashes) that you've moved around in. Find the commit you destroyed, and do this:

git checkout -b someNewBranchName shaYouDestroyed 

You've now resurrected that commit. Commits don't actually get destroyed in Git for some 90 days, so you can usually go back and rescue one you didn't mean to get rid of.

vote vote


There are two ways to "undo" your last commit, depending on whether or not you have already made your commit public (pushed to your remote repository):

How to undo a local commit

Let's say I committed locally, but now I want to remove that commit.

git log     commit 101: bad commit    # Latest commit. This would be called 'HEAD'.     commit 100: good commit   # Second to last commit. This is the one we want. 

To restore everything back to the way it was prior to the last commit, we need to reset to the commit before HEAD:

git reset --soft HEAD^     # Use --soft if you want to keep your changes git reset --hard HEAD^     # Use --hard if you don't care about keeping the changes you made 

Now git log will show that our last commit has been removed.

How to undo a public commit

If you have already made your commits public, you will want to create a new commit which will "revert" the changes you made in your previous commit (current HEAD).

git revert HEAD 

Your changes will now be reverted and ready for you to commit:

git commit -m 'restoring the file I removed by accident' git log     commit 102: restoring the file I removed by accident     commit 101: removing a file we don't need     commit 100: adding a file that we need 

For more information, check out Git Basics - Undoing Things.

vote vote


Add/remove files to get things the way you want:

git rm classdir git add sourcedir 

Then amend the commit:

git commit --amend 

The previous, erroneous commit will be edited to reflect the new index state - in other words, it'll be like you never made the mistake in the first place.

Note that you should only do this if you haven't pushed yet. If you have pushed, then you'll just have to commit a fix normally.

vote vote


git rm yourfiles/*.class git commit -a -m "deleted all class files in folder 'yourfiles'" 


git reset --hard HEAD~1 

Warning: The above command will permanently remove the modifications to the .java files (and any other files) that you wanted to commit.

The hard reset to HEAD-1 will set your working copy to the state of the commit before your wrong commit.

Top 3 video Explaining version control - How do I undo the most recent local commits in Git?