How do I undo the most recent local commits in Git

Question

I accidentally committed the wrong files to Git  but didn t push the commit to the server yet  How can I undo those commits from the local repository

User · Answer

You can use   git reset HEAD  1    This command will delete your wrong commit without a Git log

User · Answer

In IntelliJ IDEA you can just open the Git repository log by pressing Alt 9  right mouse button click at some tag from the commits list  and select   Reset Current Branch to Here

User · Answer

If you are planning to undo a local commit entirely  whatever you change you did on the commit  and if you don t worry anything about that  just do the following command  git reset --hard HEAD 1   This command will ignore your entire commit and your changes will be lost completely from your local working tree   If you want to undo your commit  but you want your changes in the staging area  before commit just like after git add  then do the following command  git reset --soft HEAD 1  Now your committed files come into the staging area  Suppose if you want to upstage the files  because you need to edit some wrong content  then do the following command git reset HEAD  Now committed files to come from the staged area into the unstaged area  Now files are ready to edit  so whatever you change  you want to go edit and added it and make a fresh new commit  More  link broken   Archived version

User · Answer

The simplest way to undo the last commit is  git reset HEAD    This will bring the project state before you have made the commit

User · Answer

Usually  you want to undo a commit because you made a mistake and you want to fix it - essentially what the OP did when he asked the question  So really  you actually want to redo a commit   Most of the answers here focus on the command line  While the command line is the best way to use Git when you re comfortable with it  its probably a bit alien to those coming from other version control systems to Git    Here s how to do it using a GUI  If you have Git installed  you already have everything you need to follow these instructions   NOTE  I will assume here that you realised the commit was wrong before you pushed it  If you don t know what pushing means  then you probably haven t pushed  So carry on with the instructions  If you have pushed the faulty commit  the least risky way is just to follow up the faulty commit with a new commit that fixes things  the way you would do it in a version control system that does not allow you to rewrite history    That said  here s how to fix your most recent fault commit using a GUI    Navigate to your repository on the command line and start the GUI with git gui Choose  Amend last commit   You will see your last commit message  the files you staged and the files you didn t  Now change things to how you want them to look and click Commit

User · Answer

In order to remove some files from a Git commit  use the    git reset    command with the       soft    option and specify the commit before HEAD    git reset --soft HEAD 1  When running this command  you will be presented with the files from the most recent commit  HEAD  and you will be able to commit them  Now that your files are in the staging area  you can remove them  or unstage them  using the    git reset    command again    git reset HEAD  lt file gt   Note  this time  you are resetting from HEAD as you simply want to exclude files from your staging area If you are simply not interested in this file any more  you can use the    git rm    command in order to delete the file from the index  also called the staging area     git rm --cached  lt file gt   When you are done with the modifications  you can simply commit your changes again with the       amend    option    git commit --amend  To verify that the files were correctly removed from the repository  you can run the    git ls-files    command and check that the file does not appear in the file  if it was a new one of course    git ls-files    lt file1 gt    lt file2 gt   Remove File From Commit using Git Restore Since Git 2 23  there is a new way to remove files from commit  but you will have to make sure that you are using a Git version greater or equal than 2 23    git --version  Git version 2 24 1 Note  Git 2 23 was released in August 2019 and you may not have this version already available on your computer  To install newer versions of Git  you can check this tutorial  To remove files from commits  use the    git restore    command  specify the source using the       source    option and the file to be removed from the repository  For example  in order to remove the file named    myfile    from the HEAD  you would write the following command   git restore --source HEAD  --staged  --  lt file gt   As an example  let   s pretend that you edited a file in your most recent commit on your    master    branch  The file is correctly committed but you want to remove it from your Git repository  To remove your file from the Git repository  you want first to restore it    git restore --source HEAD  --staged  -- newfile    git status  On branch master Your branch is ahead of  origin master  by 1 commit   use  quot git push quot  to publish your local commits  Changes to be committed    use  quot git restore --staged  lt file gt     quot  to unstage      modified    newfile  Changes not staged for commit    use  quot git add  lt file gt     quot  to update what will be committed    use  quot git restore  lt file gt     quot  to discard changes in working directory        modified    newfile  As you can see  your file is back to the staging area  From there  you have two choices  you can choose to edit your file in order to re-commit it again  or to simply delete it from your Git repository  Remove File from Git Repository In this section  we are going to describe the steps in order to remove the file from your Git repository  First  you need to unstage your file as you won   t be able to remove it if it is staged  To unstage a file  use the    git reset    command and specify the HEAD as source    git reset HEAD newfile  When your file is correctly unstaged  use the    git rm    command with the       cached    option in order to remove this file from the Git index  this won   t delete the file on disk    git rm --cached newfile  rm  newfile  Now if you check the repository status  you will be able to see that Git staged a deletion commit    git status  On branch master Your branch is ahead of  origin master  by 1 commit   use  quot git push quot  to publish your local commits  Changes to be committed    use  quot git restore --staged  lt file gt     quot  to unstage      deleted     newfile  Now that your file is staged  simply use the    git commit    with the       amend    option in order to amend the most recent commit from your repository     git commit --amend    master 90f8bb1  Commit from HEAD   Date  Fri Dec 20 03 29 50 2019 -0500   1 file changed  2 deletions -    delete mode 100644 newfile   As you can see  this won   t create a new commit but it will essentially modify the most recent commit in order to include your changes  Remove Specific File from Git Commit In some cases  you don   t want all the files to be staged again  you only one to modify one very specific file of your repository  In order to remove a specific file from a Git commit  use the    git reset    command with the       soft    option  specify the commit before HEAD and the file that you want to remove    git reset HEAD  --  lt file gt   When you are done with the modifications  your file will be back in the staging area  First  you can choose to remove the file from the staging area by using the    git reset    command and specify that you want to reset from the HEAD    git reset HEAD  lt file gt   Note  it does not mean that you will lose the changes on this file  just that the file will be removed from the staging area  If you want to completely remove the file from the index  you will have to use the    git rm    command with the       cached    option    git reset HEAD  lt file gt   In order to make sure that your file was correctly removed from the staging area  use the    git ls-files    command to list files that belong to the index    git ls-files  When you are completely done with your modifications  you can amend the commit you removed the files from by using the    git commit    command with the       amend    option    git commit --amend

User · Answer

Undo a commit  amp  redo   git commit -m  quot Something terribly misguided quot     0  Your Accident    git reset HEAD                                  1    edit files as necessary                         2    git add                                         3    git commit -c ORIG HEAD                         4    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    Make corrections to working tree files   git add anything that you want to include in your new commit   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   amp  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

User · Answer

WHAT TO USE  reset --soft or reset --hard   I am just adding two cents for  Kyralessa s answer   If you are unsure what to use go for --soft  I used this convention to remember it --soft for safe    Why    If you choose --hard by mistake you will LOSE your changes as it wasn t before  If you choose --soft by mistake you can achieve the same results of --hard by applying additional commands  git reset HEAD file html git checkout -- file html   Full example  echo  some changes      gt  file html git add file html git commit -m  wrong commit     I need to reset git reset --hard HEAD 1  cancel changes    OR git reset --soft HEAD 1   Back to staging git reset HEAD file html   back to working directory git checkout -- file html   cancel changes   Credits goes to  Kyralessa

User · Answer

If you want to undo the very first commit in your repo  You ll encounter this problem     git reset HEAD  fatal  ambiguous argument  HEAD    unknown revision or path not in the working tree  Use  --  to separate paths from revisions  like this   git  lt command gt    lt revision gt      --   lt file gt         The error occurs because if the last commit is the initial commit  or no parents  of the repository  there is no HEAD    Solution  If you want to reset the only commit on  master  branch    git update-ref -d HEAD   git rm --cached -r

User · Answer

Reset the working tree to the last commit   git reset --hard HEAD      Clean unknown files from the working tree   git clean       see - Git Quick Reference  NOTE  This command will delete your previous commit  so use with caution  git reset --hard is safer

User · Answer

How to undo the last Git commit   To restore everything back to the way it was prior to the last commit  we need to reset to the commit before HEAD    If you don t want to keep your changes that you made   git reset --hard HEAD   If you want to keep your changes   git reset --soft HEAD     Now check your git log  It will show that our last commit has been removed

User · Answer

Use this command   git checkout -b old-state number commit

User · Answer

Here is site  Oh shit  git    Here are many recipes how to undo things in Git  Some of them      Oh shit  I need to change the message on my last commit    git commit --amend   follow prompts to change the commit message      Oh shit  I accidentally committed something to master that should have been on a brand new branch      Create a new branch from the current state of master git branch some-new-branch-name   Remove the commit from the master branch git reset HEAD  --hard git checkout some-new-branch-name   Your commit lives in this branch now

User · Answer

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

User · Answer

In order to get rid of  all the changes in  last commit  last 2 commits and last n commits   git reset --hard HEAD 1 git reset --hard HEAD 2     git reset --hard HEAD n   And  to get rid of anything after a specific commit   git reset --hard  lt commit sha gt    e g     git reset --hard 0d12345      PS    1- Be careful  because of  hard  option  it deletes the local changes   in your repo as well and reverts to the previous mentioned commit  You   should run this if you are sure you messed up in your last commit s    and would like to go back in time        2- Usually 7 letters of  commit sha  is enough  but in bigger   projects  you may need up to 12 letters to guarantee be unique  You   also can mention the whole 40 letters sha       3- The above commands work in Github for Windows as well

User · Answer

If you would like to eliminate the wrong files you should do   git reset --soft  lt your last good commit hash here gt  Here  if you do git status  you will see the files in the staging area  You can select the wrong files and take them down from the staging area   Like the following   git reset wrongFile1 wrongFile2 wrongFile3  You can now just add the files that you need to push   git add goodFile1 goodFile2  commit them   git commit -v or git commit -am  Message   and push  git push origin master  However  if you do not care about the changed files you can hard reset to previous good commit and push everything to the server   by   git reset --hard  lt your last good commit hash here gt    git push origin master  If you already published your wrong files to the server  you can use the --force flag to push to the server and edit the history   git push --force origin master

User · Answer

Another way   Checkout the branch you want to revert  then reset your local working copy back to the commit that you want to be the latest one on the remote server  everything after it will go bye-bye   To do this  in SourceTree I right-clicked on the and selected  Reset BRANCHNAME to this commit    Then navigate to your repository s local directory and run this command   git -c diff mnemonicprefix false -c core quotepath false push -v -f --tags REPOSITORY NAME BRANCHNAME BRANCHNAME   This will erase all commits after the current one in your local repository but only for that one branch

User · Answer

How to fix the previous local commit  Use git-gui  or similar  to perform a git commit --amend  From the GUI you can add or remove individual files from the commit  You can also modify the commit message    How to undo the previous local commit  Just reset your branch to the previous location  for example  using gitk or git rebase   Then reapply your changes from a saved copy  After garbage collection in your local repository  it will be like the unwanted commit never happened  To do all of that in a single command  use git reset HEAD 1   Word of warning  Careless use of git reset is a good way to get your working copy into a confusing state  I recommend that Git novices avoid this if they can   How to undo a public commit  Perform a reverse cherry pick  git-revert  to undo the changes   If you haven t yet pulled other changes onto your branch  you can simply do     git revert --no-edit HEAD   Then push your updated branch to the shared repository   The commit history will show both commits  separately     Advanced  Correction of the private branch in public repository  This can be dangerous -- be sure you have a local copy of the branch to repush   Also note  You don t want to do this if someone else may be working on the branch   git push --delete  branch name     remove public version of branch   Clean up your branch locally then repush     git push origin  branch name    In the normal case  you probably needn t worry about your private-branch commit history being pristine   Just push a followup commit  see  How to undo a public commit  above   and later  do a squash-merge to hide the history

User · Answer

Rebasing and dropping commits are the best when you want to keep the history clean useful when proposing patches to a public branch etc   If you have to drop the topmost commit then the following one-liner helps  git rebase --onto HEAD 1 HEAD   But if you want to drop 1 of many commits you did say  a -  b -  c -  d -  master  and you want to drop commit  c   git rebase --onto b c   This will make  b  as the new base of  d  eliminating  c

User · Answer

The difference between git reset --mixed  --soft and --hard     Prerequisite  When a modification to an existing file in your   repository is made  this change is initially considered as unstaged    In order to commit the changes  it needs to be staged which means   adding it to the index using git add  During a commit operation  the   files that are staged gets added to an index    Let s take an example    - A - B - C  master    HEAD points to C and the index matches C   --soft   When we execute git reset --soft B with the intention of removing the commit C and pointing the master HEAD to B   The master HEAD will now point to B  but the index still has changed from C   When executing git status you could see the files indexed in commit C as staged   Executing a git commit at this point will create a new commit with the same changes as C   --mixed   Execute git reset --mixed B   On execution  master HEAD will point to B and the index is also modified to match B because of the mixed flag used    If we run git commit at this point  nothing will happen since the index matches HEAD  We still have the changes in the working directory  but since they re not in the index  git status shows them as unstaged   To commit them  you would git add and then commit as usual    --hard   Execute git reset --hard B On execution  master HEAD will point to B and modifies your working directory The changes added in C and all the uncommitted changes will be removed  Files in the working copy will match the commit B  this will result in loosing permanently all changes which were made in commit C plus uncommitted changes   Hope this comparison of flags that are available to use with git reset command will help someone to use them wisely  Refer these for further details link1  amp  link2

User · Answer

You can undo your commits from the local repository  Please follow the below scenario   In the below image I check out the  test  branch  using Git command git checkout -b test  as a local and check status  using Git command git status  of local branch that there is nothing to commit     In the next image image you can see here I made a few changes in Filter1 txt and added that file to the staging area and then committed my changes with some message  using Git command git commit -m  Doing commit to test revert back      -m is for commit message     In the next image you can see your commits log whatever you have made commits  using Git command git log      So in the above image you can see the commit id with each commit and with your commit message now whatever commit you want to revert back or undo copy that commit id and hit the below Git command  git revert   paste your commit id    Example   git revert 9ca304ed12b991f8251496b4ea452857b34353e7     I have reverted back my last commit  Now if you check your Git status  you can see the modified file which is Filter1 txt and yet to commit

User · Answer

Suppose you made a wrong commit locally and pushed it to a remote repository  You can undo the mess with these two commands   First  we need to correct our local repository by going back to the commit that we desire   git reset --hard  lt previous good commit id where you want the local repository  to go gt    Now we forcefully push this good commit on the remote repository by using this command   git push --force-with-lease   The  with-lease  version of the force option it will prevent accidental deletion of new commits you do not know about  i e  coming from another source since your last pull

User · Answer

I prefer to use git rebase -i for this job  because a nice list pops up where I can choose the commits to get rid of  It might not be as direct as some other answers here  but it just feels right   Choose how many commits you want to list  then invoke like this  to enlist last three   git rebase -i HEAD 3   Sample list  pick aa28ba7 Sanity check for RtmpSrv port pick c26c541 RtmpSrv version option pick 58d6909 Better URL decoding support   Then Git will remove commits for any line that you remove

User · Answer

I got the commit ID from bitbucket and then did   git checkout commitID     Example   git checkout 7991072     And it reverted it back up to that working copy of that commit

User · Answer

To reset to the previous revision  permanently deleting all uncommitted changes    git reset --hard HEAD 1

User · Answer

If you have Git Extras installed  you can run git undo to undo the latest commit  git undo 3 will undo the last three commits

User · Answer

Undo the Last Commit  There are tons of situations where you really want to undo that last commit into your code  E g  because you d like to restructure it extensively - or even discard it altogether   In these cases  the  reset  command is your best friend     git reset --soft HEAD 1   The above command  reset  will rewind your current HEAD branch to the specified revision  In our example above  we d like to return to the one before the current revision - effectively making our last commit undone   Note the --soft flag  this makes sure that the changes in undone revisions are preserved  After running the command  you ll find the changes as uncommitted local modifications in your working copy   If you don t want to keep these changes  simply use the --hard flag  Be sure to only do this when you re sure you don t need these changes any more     git reset --hard HEAD 1

User · Answer

Replace your local version  including your changes with the server version  These two lines of code will force Git to pull and overwrite local   Open a command prompt and navigate to the Git project root  If you use Visual Studio  click on Team  Sync and click on  Open Command Prompt   see the image  below     Once in the Cmd prompt  go ahead with the following two instructions   git fetch --all   Then you do  git reset --hard origin master   This will overwrite the existing local version with the one on the Git server

User · Answer

Try this  hard reset to previous commit where those files were not added  then   git reset --hard  lt commit hash gt    Make sure you have a backup of your changes just in case  as it s a hard reset  which means they ll be lost  unless you stashed earlier

User · Answer

git reset HEAD  n  will reset your last n actions  For reset  for the last action  use git reset HEAD  1

User · Answer

In my case I accidentally committed some files I did not want to  So I did the following and it worked   git reset --soft HEAD  git rm --cached  files you do not need  git add  files you need  git commit -c ORIG HEAD   Verify the results with gitk or git log --stat

User · Answer

There are many ways to do it   Git command to undo the last commit  previous commits   Warning  Do Not use --hard if you do not know what you are doing  --hard is too dangerous  and it might delete your files   Basic command to revert the commit in Git is     git reset --hard  lt COMMIT -ID gt    or    git reset --hard HEAD  lt n gt    COMMIT-ID  ID for the commit  n   is number of last commits you want to revert  You can get the commit id as shown below       git log --oneline    d81d3f1 function to subtract two numbers  be20eb8 function to add two numbers  bedgfgg function to mulitply two numbers   where d81d3f1 and be20eb8 are commit id   Now let s see some cases   Suppose you want to revert the last commit  d81d3f1    Here are two options     git reset --hard d81d3f1   or    git reset --hard HEAD 1   Suppose you want to revert the commit  be20eb8      git reset --hard be20eb8   For more detailed information you can refer and try out some other commands too for resetting head to a specified state     git reset --help

User · Answer

A single command   git reset --soft  HEAD      It works great to undo the last local commit

User · Answer

git revert commit   This will generate the opposite changes from the commit which you want to revert back  and then just commit that changes  I think this is the simplest way   https   git-scm com docs git-revert

User · Answer

What i do each time i need to undo a commit commits are    git reset HEAD  lt n gt      the number of last commits i need to undo git status    optional  All files are now in red  unstaged   Now  i can add  amp  commit just the files that i need    git add  lt file names gt   amp  git commit -m  message  -m  details   Optional  I can rollback the changes of the rest files  if i need  to their previous condition  with checkout      git checkout  lt filename gt   if i had already pushed it to remote origin  previously    git push origin  lt branch name gt  -f    use -f to force the push

User · Answer

Reference  How to undo last commit in Git   If you have Git Extensions installed you can easily undo revert any commit  you can download git extensions from here    Open Git Extensions  right click on the commit you want to revert then select  Revert commit       A popup will be opened  see the screenshot below     Select  Automatically create a commit  if you want to directly commit the reverted changes or if you want to manually commit the reverted changes keep the box un-selected and click on  Revert this commit  button

User · Answer

Before answering let s add some background  explaining what is this HEAD   First of all what is HEAD   HEAD is simply a reference to the current commit  latest  on the current branch  There can only be a single HEAD at any given time   excluding git worktree   The content of HEAD is stored inside  git HEAD and it contains the 40 bytes SHA-1 of the current commit     detached HEAD  If you are not on the latest commit - meaning that HEAD is pointing to a prior commit in history its called detached HEAD     On the command line  it will look like this- SHA-1 instead of the branch name since the HEAD is not pointing to the tip of the current branch      A few options on how to recover from a detached HEAD     git checkout  git checkout  lt commit id gt  git checkout -b  lt new branch gt   lt commit id gt  git checkout HEAD X    x is the number of commits t go back   This will checkout new branch pointing to the desired commit  This command will checkout to a given commit  At this point  you can create a branch and start to work from this point on     Checkout a given commit     Doing so will result in a  detached HEAD  which mean that the  HEAD    is not pointing to the latest so you will need to checkout branch   in order to be able to update the code  git checkout  lt commit-id gt     create a new branch forked to the given commit git checkout -b  lt branch name gt      git reflog  You can always use the reflog as well  git reflog will display any change which updated the HEAD and checking out the desired reflog entry will set the HEAD back to this commit    Every time the HEAD is modified there will be a new entry in the reflog  git reflog git checkout HEAD         This will get you back to your desired commit      git reset --hard  lt commit id gt    Move  your HEAD back to the desired commit     This will destroy any local modifications    Don t do it if you have uncommitted work you want to keep  git reset --hard 0d1d7fc32    Alternatively  if there s work to keep  git stash git reset --hard 0d1d7fc32 git stash pop   This saves the modifications  then reapplies that patch after resetting    You could get merge conflicts if you ve modified things which were   changed since the commit you reset to     Note   Since Git 2 7  you can also use the git rebase --no-autostash as well      git revert  lt sha-1 gt    Undo  the given commit or commit range  The reset command will  undo  any changes made in the given commit  A new commit with the undo patch will be committed while the original commit will remain in the history as well     add new commit with the undo of the original one    the  lt sha-1 gt  can be any commit s  or commit range git revert  lt sha-1 gt      This schema illustrates which command does what  As you can see there reset  amp  amp  checkout modify the HEAD

User · Answer

Type git log and find the last commit hash code and then enter   git reset  lt the previous co gt

User · Answer

There are two main scenarios  You haven t pushed the commit yet  If the problem was extra files you commited  and you don t want those on repository   you can remove them using git rm and then commiting with --amend  git rm  lt pathToFile gt    You can also remove entire directories with -r  or even combine with other Bash commands  git rm -r  lt pathToDirectory gt  git rm   find -name    class     After removing the files  you can commit  with --amend option  git commit --amend -C HEAD   the -C option is to use the same commit message   This will rewrite your recent local commit removing the extra files  so  these files will never be sent on push and also will be removed from your local  git repository by GC   You already pushed the commit  You can apply the same solution of the other scenario and then doing git push with the -f option  but it is not recommended since it overwrites the remote history with a divergent change  it can mess your repository    Instead  you have to do the commit without --amend  remember this about -amend   That option rewrites the history on the last commit

User · Answer

You can undo your Git commits in two ways  First is you can use git revert  if you want to keep your commit history   git revert HEAD 3 git revert  lt hashcode of commit gt    Second is you can use git reset  which would delete all your commit history and bring your head to commit where you want it   git reset  lt hashcode of commit gt  git reset HEAD 3   You can also use the --hard keyword if any of it starts behaving otherwise  But  I would only recommend it until it s extremely necessary

User · Answer

Just reset it doing the command below using git   git reset --soft HEAD 1   Explain  what git reset does  it s basically reset to any commit you d like to go back to  then if you combine it with --soft key  it will go back  but keep the  changes in your file s   so you get back to the stage which the file was just added  HEAD is the head of the branch and if you combine with  1  in this case you also use HEAD    it will go back only one commit which what you want     I create the steps in the image below in more details for you  including all steps that may happens in real situations and committing the code

User · Answer

You need to do the easy and fast      git commit --amend   if it s a private branch or      git commit -m  Replace  class files with  java files    if it s a shared or public branch

User · Answer

git reset --soft HEAD 1    git status  On branch master Your branch is ahead of  origin master  by 1 commit     use  git push  to publish your local commits   Changes to be committed     use  git restore --staged  lt file gt      to unstage          new file    file1    git log --oneline --graph     90f8bb1  HEAD - gt  master  Second commit    7083e29 Initial repository commit

User · Answer

Use this command  git checkout -b old-state 0d1d7fc32

User · Answer

Everybody comments in such a complicated manner  If you want to remove the last commit from your branch  the simplest way to do it is  git reset --hard HEAD 1  Now to actually push that change to get rid of your last commit  you have to git push --force  And that s it  This will remove your last commit

User · Answer

git commit -m  Initial commit    git add forgotten file   git commit --amend  It   s important to understand that when you   re amending your last commit  you   re not so much fixing it as replacing it entirely with a new  improved commit that pushes the old commit out of the way and puts the new commit in its place  Effectively  it   s as if the previous commit never happened  and it won   t show up in your repository history  The obvious value to amending commits is to make minor improvements to your last commit  without cluttering your repository history with commit messages of the form     Oops  forgot to add a file    or    Darn  fixing a typo in last commit     2 4 Git Basics - Undoing Things

User · Answer

On SourceTree  GUI for GitHub   you may right-click the commit and do a  Reverse Commit   This should undo your changes   On the terminal   You may alternatively use   git revert   Or   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 your changes

User · Answer

If you want to permanently undo it and you have cloned some repository   The commit id can be seen by   git log    Then you can do -  git reset --hard  lt commit id gt   git push origin  lt branch name gt  -f

User · Answer

To change the last commit  Replace the files in the index   git rm --cached   class git add   java   Then  if it s a private branch  amend the commit   git commit --amend   Or  if it s a shared branch  make a new commit   git commit -m  Replace  class files with  java files       To change a previous commit  use the awesome interactive rebase      ProTip     Add   class to a gitignore to stop this happening again     To revert a commit  Amending a commit is the ideal solution if you need to change the last commit  but a more general solution is reset   You can reset Git to any commit with   git reset   N   Where N is the number of commits before HEAD  and    resets to the previous commit   So  instead of amending the commit  you could use   git reset    git add   java git commit -m  Add  java files    Check out git help reset  specifically the sections on --soft --mixed and --hard  for a better understanding of what this does   Reflog  If you mess up  you can always use the reflog to find dropped commits     git reset      git reflog c4f708b HEAD  0   reset  moving to    2c52489 HEAD  1   commit  added some  class files   git reset 2c52489     and you re back where you started

User · Answer

You can use git revert  lt commit-id gt    And for getting the commit ID  just use git log

User · Answer

Undo last commit   git reset --soft HEAD  or git reset --soft HEAD   This will undo the last commit   Here --soft means reset into staging   HEAD  or HEAD  means to move to commit before HEAD     Replace last commit to new commit   git commit --amend -m  message    It will replace the last commit with the new commit

User · Answer

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

User · Answer

I wrote about this ages ago after having these same problems myself  How to delete revert a Git commit Basically you just need to do  git log  get the first seven characters of the SHA hash  and then do a git revert  lt sha gt  followed by git push --force  You can also revert this by using the Git revert command as follows  git revert  lt sha gt  -m -1 and then git push

User · Answer

Assuming you re working in Visual Studio  if you go in to you branch history and look at all of your commits  simply select the event prior to the commit you want to undo  right-click it  and select Revert   Easy as that

User · Answer

If you are working with SourceTree  this will help you   Right click on the commit then select  Reset  current branch  master to this commit  and last select   Soft  reset

User · Answer

Simple  run this in your command line   git reset --soft HEAD

User · Answer

If the repository has been committed locally and not yet pushed to the server  another crude layman way of solving it would be   Git clone the repository in another location  Copy the modifications  files directories  from the original repository into this new one  Then commit and push with the changes from the new one  Replace the old repository with this new one

User · Answer

Undo the last commit   git reset --soft HEAD  or git reset --soft HEAD    This will undo the last commit   Here --soft means reset into staging   HEAD  or HEAD  means to move to commit before HEAD   Replace the last commit to new commit   git commit --amend -m  message    It will replace the last commit with the new commit

User · Answer

There are two ways to  quot undo quot  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  quot revert quot  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

User · Answer

VISUAL STUDIO USERS  2015  etc    If you cannot synchronise in Visual Studio as you are not allowed to push to a branch like  development  then as much as I tried  in Visual Studio NEITHER the REVERT NOR the RESET  hard or soft  would work   Per the answer with TONS OF VOTES   Use this at the command prompt of root of your project to nuke anything that will attempt to get pushed   git reset --hard HEAD 1   Backup or zip your files just in case you don t wish to lose any work  etc

User · Answer

git push --delete  branch name    this will be removing the public version of your branch  git push origin  branch name    This will add the previous version back

User · Answer

Use git revert  lt commit-id gt    To get the commit ID  just use git log

User · Answer

For sake of completeness  I will give the one glaringly obvious method that was overlooked by the previous answers   Since the commit was not pushed  the remote was unchanged  so    Delete the local repository  Clone the remote repository    This is sometimes necessary if your fancy Git client goes bye-bye   eg  non-fast-forward errors   Don t forget to re-commit your saved changes since the last push

User · Answer

I have found this site which describes how to undo things that you have committed into the repository   Some commands   git commit --amend          Change last commit git reset HEAD 1 --soft     Undo last commit

User · Answer

If you simply want to trash all your local changes commits and make your local branch look like the origin branch you started from     git reset --hard origin branch-name

User · Answer

I wanted to undo the latest five commits in our shared repository  I looked up the revision id that I wanted to rollback to  Then I typed in the following   prompt gt  git reset --hard 5a7404742c85 HEAD is now at 5a74047 Added one more page to catalogue prompt gt  git push origin master --force Total 0  delta 0   reused 0  delta 0  remote  bb acl  neoneye is allowed  accepted payload  To git bitbucket org thecompany prometheus git    09a6480   5a74047 master - gt  master  forced update  prompt gt

User · Answer

I usually first find the commit hash of my recent commit  git log  It looks like this  commit  long hash  Copy this long hash and reset to it  go back to same files state it was on that commit   git reset --hard  insert long hash without braces

User · Answer

For a local commit  git reset --soft HEAD 1   or if you do not remember exactly in which commit it is  you might use  git rm --cached  lt file gt    For a pushed commit  The proper way of removing files from the repository history is using git filter-branch  That is   git filter-branch --index-filter  git rm --cached  lt file gt   HEAD   But I recomnend you use this command with care  Read more at git-filter-branch 1  Manual Page

User · Answer

Remove a wrong commit that is already pushed to Github  git push origin   previous good commit id   branch name    Please specify the last good commit id you would like to reset back in Github   For example  If latest commit id is wrong then specify the previous commit id in above git command with the branch name    You can get previous commit id using git log

User · Answer

In my case I committed and pushed to the wrong branch  so what I wanted was to have all my changes back so I can commit them to a new correct branch  so I did this   On the same branch that you committed and pushed  if you type  git status  you won t see anything new because you committed and pushed  now type   git reset --soft HEAD 1  This will get all your changes files  back in the stage area  now to get them back in the working directory unstage  you just type   git reset FILE   Where  File  is the file that you want to commit again  Now  this FILE should be in the working directory unstaged  with all the changes that you did  Now you can change to whatever branch that you want and commit the changes in that branch  Hope this helps other people that made the same mistake I did  Of course  the initial branch that you committed is still there with all changes  but in my case that was ok  if it is not for you-you can look for ways to revert that commit in that branch

User · Answer

Get last commit ID by using this command  in the log one on the top it is the latest one    git log   Get the commit id  GUID  and run this command   git revert  lt commit id gt

User · Answer

git rm yourfiles   class git commit -a -m  deleted all class files in folder  yourfiles     or  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

User · Answer

Do as the following steps  It might help you  Step 1 Hit git log From the list of log  find the last commit hash code and then enter  Step 2 git reset  lt hash code gt

User · Answer

Just use git reset --hard  lt last good SHA gt  to reset your changes and give new commit  You can also use git checkout --  lt bad filename gt

User · Answer

To undo your local commit you use git reset  lt commit gt   Also that tutorial is very helpful to show you how it works   Alternatively  you can use git revert  lt commit gt   reverting should be used when you want to add another commit that rolls back the changes  but keeps them in the project history

User · Answer

How to edit an earlier commit  Generally I don t want to undo a bunch of commits  but rather edit an earlier commit to how I wish I had committed it in the first place   I found myself fixing a past commit frequently enough that I wrote a script for it   Here s the workflow    git commit-edit  lt commit-hash gt    This will drop you at the commit you want to edit   The changes of the commit will be unstaged  ready to be staged as you wish it was the first time  Fix and stage the commit as you wish it had been in the first place    You may want to use git stash save --keep-index to squirrel away any files you re not committing  Redo the commit with --amend  eg   git commit --amend  Complete the rebase   git rebase --continue      Call this following git-commit-edit and put it in your  PATH        bin bash    Do an automatic git rebase --interactive  editing the specified commit   Revert the index and working tree to the point before the commit was staged   https   stackoverflow com a 52324605 5353461  set -euo pipefail  script name   0       warn      printf   s   s n    script name        gt  amp 2    die      warn       exit 1           -ge 2     amp  amp  die  Expected single commit to edit  Defaults to HEAD      Default to editing the parent of the most recent commit   The most recent commit can be edited with  git commit --amend  commit   git rev-parse --short    1 -HEAD        Be able to show what commit we re editing to the user if git config --get alias print-commit-1  amp  gt  dev null  then   message   git print-commit-1   commit   else   message   git log -1 --format   h  s    commit   fi  if     OSTYPE     darwin     then   sed inplace  sed -Ei     else   sed inplace  sed -Ei  fi  export GIT SEQUENCE EDITOR    sed inplace         s  pick     commit       edit   1    git rebase --quiet --interactive --autostash --autosquash   commit   git reset --quiet       git rev-parse --show-toplevel      Reset the cache of the toplevel directory to the previous commit git commit --quiet --amend --no-edit --allow-empty     Commit an empty commit so that that cache diffs are un-reversed  echo echo  Editing commit   message   gt  amp 2 echo

User · Answer

Think we have code txt file  We make some changes on it and commit  We can undo this commit in three ways  but first you should know what is the staged file    An staged file is a file that ready to commit and if you run git status this file will be shown with green color and if this is not staged for commit will be shown with red color     It means if you commit your change  your changes on this file is not saved  You can add this file in your stage with git add code txt and then commit your change     Undo last commit    Now if we want to just undo commit without any other changes  we can use  git reset --soft HEAD     If we want to undo commit and its changes  THIS IS DANGEROUS  because your change will lost   we can use  git reset --hard HEAD    And if we want to undo commit and remove changes from stage  we can use  git reset --mixed HEAD  or in a short form git reset HEAD

User · Answer

Use reflog to find a correct state  git reflog    REFLOG BEFORE RESET  Select the correct reflog  f3cb6e2 in my case  and type   git reset --hard f3cb6e2   After that the repo HEAD will be reset to that HEADid  LOG AFTER RESET  Finally the reflog looks like the picture below   REFLOG FINAL

User · Answer

HEAD   Before reset commit we should know about HEAD    HEAD is nothing but your current state in your working directory  It is represented by a commit number   Git commit   Each change assigned under a commit which is represented by a unique tag  Commits can t be deleted  So if you want your last commit  you can simply dive into it using git reset   You can dive into the last commit using two methods   Method 1   if you don t know the commit number  but want to move onto the very first   git reset HEAD 1    It will move your head to last commit   Method 2   if you know the commit you simply reset onto your known commit   git reset 0xab3   Commit number  Note  if you want to know a recent commit try git log -p -1  Here is the graphical representation

User · Answer

In these cases  the  reset  command is your best friend   git reset --soft HEAD 1   Reset will rewind your current HEAD branch to the specified revision  In our example above  we d like to return to the one before the current revision - effectively making our last commit undone   Note the --soft flag  this makes sure that the changes in undone revisions are preserved  After running the command  you ll find the changes as uncommitted local modifications in your working copy   If you don t want to keep these changes  simply use the --hard flag  Be sure to only do this when you re sure you don t need these changes anymore   git reset --hard HEAD 1

User · Answer

Just undo the last commit    git reset --soft HEAD    Or undo the time before last time commit    git reset --soft HEAD 2   Or undo any previous commit    git reset --soft  lt commitID gt     you can get the commitID using git reflog   When you undo a previous commit  remember to clean the workplace with  git clean   More details can be found in the docs  git-reset

User · Answer

You can always do a git checkout  lt SHA code gt   of the previous version and then commit again with the new code

User · Answer

First run    git reflog   It will show you all the possible actions you have performed on your repository  for example  commit  merge  pull  etc   Then do   git reset --hard ActionIdFromRefLog

User · Answer

To undo the last local commit  without throwing away its changes  I have this handy alias in    gitconfig   alias    undo   reset --soft HEAD    Then I simply use git undo which is super-easy to remember

User · Answer

git reset --soft HEAD 1   Reset will rewind your current HEAD branch to the specified revision   Note the --soft flag  this makes sure that the changes in undone revisions are preserved  After running the command  you ll find the changes as uncommitted local modifications in your working copy   If you don t want to keep these changes  simply use the --hard flag  Be sure to only do this when you re sure you don t need these changes anymore    git reset --hard HEAD 1      Undoing Multiple Commits   git reset --hard 0ad5a7a6   Keep in mind  however  that using the reset command undoes all commits that came after the one you returned to

User · Answer

Find the last commit hash code by seeing the log by   git log   Then  git reset  lt the previous co gt

User · Answer

A Typical Git Cycle In speaking of Git-related commands in the previous answers  I would like to share my typical Git cycles with all readers which may helpful  Here is how I work with Git   Cloning the first time from the remote server git clone  project  Pulling from remote  when I don t have a pending local commit to push  git pull  Adding a new local file1 into  to be committed list  just imagine  to be committed list means staged area  git add  file1  Removing mistakenly added file2 from  to be committed list  assume that file2 is added like step 3  which I didn t want  git reset  file2  Committing file1 which is in  to be committed list git commit -m  quot commit message description quot   Syncing local commit with remote repository before pushing git pull --rebase  Resolving when conflict occurs prerequisite configure mergetool git mergetool  resolve merging here  also can manually merge  Adding conflict-resolved files  let s say file1  git add  file1  Continuing my previous rebase command git rebase --continue  Pushing ready and already synced last local commit git push origin head refs for  branch   branch   master  dev  etc

User · Answer

I validate an efficient method proposed  and here is a concrete example using it  In case you want to permanently undo cancel your last commit  and so on  one by one  as many as you want  three steps  1  Get the id   SHA of the commit you want to arrive on with  of course   git log  2  Delete your previous commit with   git reset --hard  your SHA   3  Force the new local history upon your origin GitHub with the -f option  the last commit track will be erased from the GitHub history    git push origin master -f  Example   git log   Last commit to cancel   commit e305d21bdcdc51d623faec631ced72645cca9131  HEAD - gt  master  origin master  origin HEAD  Author  Christophe  lt blabla bla com gt  Date    Thu Jul 30 03 42 26 2020  0200  U2 30 S45  updating files package json  amp  yarn lock for GitHub Web Page from docs CV Portfolio      Commit we want now on HEAD    commit 36212a48b0123456789e01a6c174103be9a11e61 Author  Christophe  lt blabla bla com gt  Date    Thu Jul 30 02 38 01 2020  0200  First commit  new title  Reach the commit before by deleting the last one   git reset --hard 36212a4  HEAD is now at 36212a4 First commit  new title  Check it s OK   git log  commit 36212a48b0123456789e01a6c174103be9a11e61  HEAD - gt  master  Author  Christophe  lt blabla bla com gt  Date    Thu Jul 30 02 38 01 2020  0200      First commit  new title    git status  On branch master Your branch is behind  origin master  by 1 commit  and can be fast-forwarded    use  quot git pull quot  to update your local branch   nothing to commit  working tree clean  Update your history on the Git Hub    git push origin master -f  Total 0  delta 0   reused 0  delta 0   pack-reused 0 To https   github com  GitUser bla bla React-Apps git    e305d21   36212a4 master - gt  master  forced update   Check it s all right   git status  On branch master Your branch is up to date with  origin master    nothing to commit  working tree clean    gt  Done

User · Answer

If you have committed junk but not pushed   git reset --soft HEAD 1      HEAD 1 is a shorthand for the commit before head  Alternatively you can refer to the SHA-1 of the hash if you want to reset to  --soft option will delete the commit but it will leave all your changed files  Changes to be committed   as git status would put it       If you want to get rid of any changes to tracked files in the working tree since the commit before head use  --hard  instead    OR     If you already pushed and someone pulled which is usually my case  you can t use git reset  You can however do a git revert    git revert HEAD      This will create a new commit that reverses everything introduced by the accidental commit

User · Answer

Use SourceTree  graphical tool for Git  to see your commits and tree  You can manually reset it directly by right clicking it

[git] How do I undo the most recent local commits in Git?

Examples related to git

Examples related to version-control

Examples related to git-commit

Examples related to undo