How can I undo pushed commits using Git?

A solution that keeps no traces of the "undo".

NOTE: Don't do this if someone already pulled your change (I would use this only on my personal repo.)

Run:

git reset <previous label or sha1> 

Note: previous means the commit before the erroneous commit

This will re-checkout all the updates locally (so git status will list all updated files, meaning, the files you changed/added/.. and were committed).

Then you "do your work" and re-commit your changes (Note: This step is optional).

git commit -am "blabla" 

At this moment your local tree differs from the remote

git push -f <remote-name> <branch-name> 

will force the remote branch to take this push and remove the previous one (specifying remote-name and branch-name is not mandatory but is recommended to avoid updating all branches with update flag).

!! Watch-out some tags may still be pointing removed commit !! how-to-delete-a-remote-tag

In these cases, I

• In the server, move the cursor back to the last known good commit:

   git push -f origin <last_known_good_commit>:<branch_name> 

• Locally, do the same:

   git reset --hard <last_known_good_commit> # ^^^^^^ # optional 

See a full example on a branch my_new_branch that I created for this purpose:

git branch 

Output:

my_new_branch 

This is the recent history after adding some stuff to myfile.py:

git log 

Output:

commit 80143bcaaca77963a47c211a9cbe664d5448d546 Author: me Date: Wed Mar 23 12:48:03 2016 +0100 Adding new stuff in myfile.py commit b4zad078237fa48746a4feb6517fa409f6bf238e Author: me Date: Tue Mar 18 12:46:59 2016 +0100 Initial commit 

I want to get rid of the last commit, which was already pushed, so I run:

git push -f origin b4zad078237fa48746a4feb6517fa409f6bf238e:my_new_branch 

Output:

Total 0 (delta 0), reused 0 (delta 0) To [email protected]:me/myrepo.git + 80143bc...b4zad07 b4zad078237fa48746a4feb6517fa409f6bf238e -> my_new_branch (forced update) 

Nice! Now I see the file that was changed on that commit (myfile.py) shows in "not staged for commit":

git status 

Output:

On branch my_new_branch Your branch is up-to-date with 'origin/my_new_branch'. Changes not staged for commit: (use "git add <file>..." to update what will be committed) (use "git checkout -- <file>..." to discard changes in working directory) modified: myfile.py no changes added to commit (use "git add" and/or "git commit -a") 

Since I don't want these changes, I just move the cursor back locally as well:

git reset --hard b4zad078237fa48746a4feb6517fa409f6bf238e 

Output:

HEAD is now at b4zad07 Initial commit 

So now HEAD is in the previous commit, both in local and remote:

git log 

Output:

commit b4zad078237fa48746a4feb6517fa409f6bf238e Author: me Date: Tue Mar 18 12:46:59 2016 +0100 Initial commit 

This will remove your pushed commits

git reset --hard 'xxxxx' git clean -f -d git push -f 

Make a backup just in case

Two notes bumped up from comments:

• 'xxxxx' is the hash code of the last commit that you want to keep.

• clean ⚠️ is dangerous. It removes files, not under version control!

You can revert (or you can also call it delete) the Git Commit both locally and remotely if you follow the steps as given below via the Git command line.

Run the following command to see the commit id that you want to revert

git log --oneline --decorate --graph 

You will get like a following screenshot

If you also check remote (via Web Interface) then you can see that this would be same as shown below

As per screenshot currently you are on commit id e110322. However, you want to revert back to 030bbf6 both LOCALLY and remotely.

Perform the following steps to DELETE/REVERT Commits Locally+Remotely

First locally, reverting to commit id 030bbf6

git reset --hard 030bbf6 

Followed by

git clean -f -d 

These two commands clean force reset to commit stage 030bbf6 as shown below in snapshot

Now if you run git status, then you'll see that you are TWO Commits BEHIND from the remote branch as shown below

Run following to update your indexes (if there are any updates). It is recommended that you ask all developers not to accept any pull requests on main remote branch.

git fetch --all 

Once you are done with it then you are required to Push this commit forcefully by using + symbol in-front of branch as shown below. I have used here as master branch, you can replace it with any

Code

git push -u origin +master 

Now if you see the web interface of remote then commit there should be reverted as well.

Let's say 61234 is the sha-number of the last good commit you want to keep.

git reset --hard 61234 git push -f 


 will remove completely all wrong commits without any trace.

Note: If you wanted to push (the commit you reset to) to a specific branch you'd use git push -f origin branch-name instead.

A 2020 simple way:

git reset <commit_hash> 

(The SHA-1 hash value of the last commit you want to keep).

You will keep the now uncommitted changes locally.

If you want to push again, you have to do:

git push -f 

git revert HEAD -m 1 

In the above code line. "Last argument represents"

• 1 - reverts one commits.

• 2 - reverts last two commits.

• n - reverts last n commits.

You need to push after this command to take the effect on remote. You have other options like specifying the range of commits to revert. This is one of the option.

Later use git commit -am "COMMIT_MESSAGE" then git push or git push -f

Here is my way:

Let's say the branch name is develop.

# Checkout a new temp branch based on one history commit # (command to get history commit hashes: git log --oneline) git checkout <last_known_good_commit_hash> # Delete the original develop branch git branch -D develop # Create a new develop branch based on the temp branch git checkout -b develop # Force update the remote with the new branch git push -f origin develop 

The reset hard worked for me: Thanks @Mo D Genensis and @vibs2006

 git reset --hard 'your last working commit hash' git clean -f -d git push -f 

TL;DR

1. git reset HEAD~1 – to go back 1 commit keeping all the changes in the working directory
2. git status will show you the changes kept
3. git add ...
4. git commit
5. git push --force-with-lease – to overwrite the original erroneous commit

There are a number of ways, like moving back commits by using git reset HEAD^, adding a ^ for every commit you want to go back, problem is the changes after that commit are then lost and can be added in a new commit. So I only do this when I only have to go one or two commits back.

To do it cleanly, use the following:

git rebase -i <hash of last good commit, 9 chars is enough> 

Now you will get a list of the commits from the last good commit to the HEAD with options what to do with each commit, going from the most recent at the top to the one just before the commit of the hash you added to the command. It will look something like this:

You can change the pick before every commit to any of the other options in the list of options. drop for instance, will remove the commit. You then save the file and the commits will be reapplied, performing the option you chose for every commit.

Now to fix the upstream, do:

git push --force-with-lease 

(With lease, so you don't accidentally cause problems for someone else working on your pushed update.)

This keeps the log clean by removing the wrong commit instead of introducing new commits fixing earlier erroneous commits.

git reset <commit_hash> (to get the<commit_hash> use git log --oneline)

git restore . to restore all the changed files to the version of yout target commit

git push origin master --force to force the push to your remote master branch. But be careful when using the force push if there is anyone working with you in the same branch

If you want fast undo last commit here is my commands

Reset the last commit but keep the changes in your working directory:

git reset HEAD~1 

This command will reset your branch to the commit before the last one but keep your changes in the working directory.

Update the Remote Repository:

git push origin +HEAD --force 

This command will forcefully update the remote repository to match your local repository.

If you are already in the downstream (local) branch of the remote branch that you need to modify, use the following two commands to undo the last commit and push the updated history to the remote: git reset --hard HEAD~1 git push -f

You can do something like

git push origin +<short_commit_sha>^:<branch_name> 

git reset --soft HEAD~<number of commits to undo> git push origin +<name of branch> 

Helped me remove the commits and push from GitHub.

1. You should have a default Git editor that works, you can set it as Notepad++, Visual Studio Code or whatever you want.

2. You need your commit hash. You can create a Git alias named git lg. It will show you the list of your commit information. There is the command

   git config --global alias.lg "log --color --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an>%Creset' --abbrev-commit --" 

3. Follow these steps

   Note: If you want to delete the first commit, you cannot use these steps.

   git lg 

   

   git rebase -i <commit-hash> 

   Important: If I want to delete commit: '43a8b12 Implement XYZ feature', I should use the commit hash of the previous commit, so there it is: git rebase -i f96b5a9

   

• Replace pick with d or drop. Save your changes and close the text editor.

   git push --force-with-lease 

If something is wrong or you cannot do it, feel free to reply to this post. I will help you with love :)

Another way to do this without revert (traces of undo):

Don't do it if someone else has pushed other commits

Create a backup of your branch, being in your branch my-branch. So in case something goes wrong, you can restart the process without losing any work done.

git checkout -b my-branch-temp 

Go back to your branch.

git checkout my-branch 

Reset, to discard your last commit (to undo it):

git reset --hard HEAD^ 

Remove the branch on remote (for example, origin remote).

git push origin :my-branch 

Repush your branch (without the unwanted commit) to the remote.

git push origin my-branch 

Done!