How To Undo Commit(s) In Git? Git Reset & Git Revert Explained. (2023)

In this article we will learn how we can undo acommitor multiplecommitsinGit. We will also look at how topushthese changes to theRemote Repository(Github) after we have undone the commit(s) in theLocal Repository.

To understand the concepts and examples used in this article, we have made a local repository synced with a remote repository on Github.

The repository consists of a single file -“File 1.txt“.

There arefivecommits in the repository, and every preceding commit hasone extra lineentered into the file. The file content based on the commits is as follows -

We will refer to this table for all the examples used in this article.

We have used git bash in the examples for local repositories.

Let us look into the following topics -

git reset HEAD- undo commit(s) in Git - (Recommended)

Sometimes we may come across a situation where we have made acommitor multiplecommits(by mistake or some other reasons) and then want toundothatcommit(s)and make thatcommit(s)disappear from thegit log.

‘git reset HEAD‘ helps us achieve just that, and using this method, weundoourcommit(s), but we don’t lose the changes to the code or files we had in those deletedcommit(s).

So to undo the unwanted commit(s) in git using git reset HEAD, this is the syntax that we need to follow -

git reset HEAD~<number-of-commits>

Let us break down and understand the above syntax -

• git resetsuggests that we are resetting commit(s).
• HEADis a pointer to the latest commit in our current branch.
• <number-of-commits>is represented by a number. It represents the number of commits we want to undo.

When we use the above code to undo a commit, our commits in the branch get deleted. But the code inside the files does not get changed. They getunstaged.

This means whatever the changes we had made in the deleted commits stay there safely, no file is lost, and all the codes remain intact.

We may make changes to them according to our needs andadd(stage)them, andcommitthem again.

Let us understand them better with examples.

Example #1

Using the code below, we will undoonelast commit -“5th Commit”from the list of commits in our local git repository.

git reset HEAD~1

In the image below, we have used the git log

command to compare the previous(before using the git reset HEAD~3) and current(after using the git reset HEAD~3) commits, and we also view the changes in the file content - “File 1.txt“ accordingly.

As can be seen, the file content stays intact even after we undo our commit in git, and if any new files were created in the deleted commit, they would be present in the repository too. The only thing is they will get unstaged.

Example #2

We will use this code to undo thethreelast commits -“5th Commit,4th Commit&3rd Commit”from the list of commits in our local git repository.

git reset HEAD~3

Let’s compare the previous(before using the git reset HEAD~3) and current(after using the git reset HEAD~3) commits using git log command, and view the changes in the file content - “File 1.txt“ accordingly.

Usinggit reset HEAD~<number-of-commits>is the recommended way to undo a commit in Git.

The unwanted commits get deleted, but the files and codes do not get affected.

Now we can rectify faults, stage and commit them again as fresh commits.

Pushing theupdated commits to Github(after undoing commits in Git)

There might be instances where after pushing our commits to the remote repository(e.g. Github), we may need to undo commit(s) in Local repository in Git and push them back to that same remote repository again.

Let’s try to understand one such scenario using the image below -

In the image above, there are five commits in the remote repository on Github, whereas the local repository has three commits(after undoing two commits).

At this point, if we try pushing our commits from the local repository to the remote repository, we will get an error saying -“Updates were rejected because the tip of your branch is behind“.

In such cases, we can force update our remote repository using the syntax below -

git push origin +HEAD:<branch-name>

In the syntax above, <branch-name>represents the current branch we are working on in our local repository(after undoing the commits).

If we are on themasterbranch, we need to typemaster.

Currently we are on the branch -“Example_2”, so we will run the following code -

git push origin +HEAD:Example_2

As we can see in the image above, after running the above code, we have successfully updated/synced our commits in the remote repository with the commits in our local repository.

This is how we push theupdated commits to Githubafter we undo commit(s) in local repository in Git.

git reset hard- undo commit(s) in Git -(powerful but destructive)

Sometimes we may come across a situation where we want toundounwantedcommit(s), make that unwanted commit(s)disappearfrom thegit log, along with undoing the changes made to codes and files at that unwanted commit(s).

git reset hard helps us achieve just that, and using this method, weundoourcommit(s), and we also discard the changes to the code or files we had in those deletedcommits.

So to undo the commit(s) in git using ‘git reset --hard‘, this is the syntax that we need to follow -

git reset --hard <commit-id>

Let’s understand the above syntax -

• git resetsuggests that we are resetting commit(s)
• hardrepresents that we are resetting the commit in a demanding manner, removing the total changes from our current Head position until that particularcommit-id
• commit-id is the unique id that represents the commit till where we want our changes to be removed

We need to put the two minuses (-) signs in front of‘hard’as shown in the above syntax.

Let’s understand ‘git reset --hard‘ with an example.

Example-

Let us undo all changes we made in the5th Commit.

We will remove all the changes we made to the repository from our current HEAD position until the4th Commit. To do so -

1. First, we will see the list of commits using thegit logcommand.
2. Then from the commit named -4th Commit, we will copy itscommit-id.
3. Lastly, we will paste this commit-id according to the syntax and run this code to undo the changes made till the4th Commit.

Here is the code that we need to run -

git reset --hard de61e821268235f6ca03a061e352bf9b1856e8eb

Refer to the image below to better understand ‘git reset --hard‘.

As we can see in the image above, our HEAD is now at the4th Commit. We have successfully undone one commit, i.e., the5th Commit, and all the file changes we made inside the5th Commitare now removed.

Using‘git reset --hard‘to undo a commit in Git is quite powerful. It takes us to any previous timestamp in our code history, but at the same time, it is destructive as well.

If we make a mistake, we will lose all the changes. So we should always be careful when using the ‘git reset --hard‘ command.

NOTE: After using ‘git reset --hard‘, if any error occurs, like -“Updates were rejected because the tip of your branch is behind” while pushing the codes to a remote repository like Github or others, follow these steps.

git revert- undo commit(s) in Git -(code gets reverted on the existing commits)

There can be instances when we have written codes in a commit(s) and later figure out that commit(s) (or the codes written in that commit(s)) is not helpful.

But we want to retain that unwanted commit(s) in the commit history and work back on a commit before that. We can do that usinggit revert.

While using git revert, all the previous commits remain intact. Only anew reverted commitis placed after all the last commits to which the HEAD will now point.

Here is the syntax of using ‘git revert‘ that can be used to undo a commit in git -

git revert <commit-id>

Let’s understand the syntax -

• git revertindicates that we are reverting our code to a particular previous commit marked by thatcommit-id.
• commit-id is the unique id that represents the commit till where we want our changes to be reverted (alongwith retaining the codes in unwanted commits)

After we have executed ‘git revert‘ using the above syntax, the window will show us a summary that we have reverted to a particular commit, and we will need to type:q(colon+q) to close that summary UI.

Let us understandgit revertwith an example.

Example-

In this example, we have five different commits.

We will add one more line to the File 1.txt file -

L for Last Commit

We will add and commit the changes with the name -Last Commit.

But now, we want to go back to the4th Commit. In other words, we want to undo all changes made in theLast Commitand5th Commitand wish to retain these commits, too, in case we need to get back to them later.

So, here is how we use ‘git revert‘ to achieve this -

• First, we will see the list of commits using thegit logcommand.

• Then from the commit named -5th Commit, we will copy itscommit-id.

• We will run this code to revert theLast Commitand5th Commitchanges.

git revert c73d320cd1e7ab976974d48662f98294db3f0f34

• If there is no conflict, we will get a summary screen of the code we reverted. In that case, we will need to type:q(colon+q) to close that summary UI.

• Sometimes, we may receive a conflict while using ‘git revert‘. In such a case, we need to -
  • open the local git repository in Visual Studio Code Editor (or any code editor of our choice)
  • go to Source Control (the button on the Left-hand side which has a git symbol on it)
  • select the file which we can see is having conflict
  • resolve the Conflicts
  • stage them.

The image below visualizes the processes we discussed above, alongwith resolving conflicts while using ‘git revert‘.

• Next we run thegit logcommand. And now we can see that ourHEADis on the4th Commit, and the changes we made in theLast Commitand5th Commitare reverted.

Alternately, we can also use‘git revert -n‘to undo commit(s) in Git for explicit committing of reverted code.

Down below is the syntax of ‘git revert -n

‘ -

git revert -n <commit-id>

Conclusion

Knowing how to undo commit(s) in Git helps us explore and test new ideas, try exciting concepts.

Being aware of the fact that we can always undo our mistakes and bring the whole code to the previous working state, enhances our coding experience.

We can use three ways to undo commit(s) in Git -

• Using git reset HEAD
• Using git reset --hard
• Using git revert

I hope you found this article helpful.

You may like to Explore -

3 methods to use Python Switch Case

Indentation in Python – Indent Error Fix

Cheers!

Happy Coding.

About the Author

This article was authored byRawnak.