Git is a well-known version control system used by the majority of developers and organizations.&nbsp;
While making commits to the git repository there might be some accidental commits involving unintended changes or deletion of files.&nbsp;
In such a case, we can easily undo commits or changes with the help of a few git commands. Undoing git commits can be done in various methods based on how we wanted to keep the git history.&nbsp;
In this article, we're going to see those different methods to git undo commits.&nbsp;
Before actually diving into it, let's initialize git and commit a few files, so that we can use that to look into various git reverting commands.
Go to your favorite command line tool and run the below commands. Make sure that you have installed git in your system.
<pre class="language-bash"><code># In the folder where you want to have a git repo
&gt; git init
&gt; echo One &gt; one.txt; echo Two &gt; two.txt; echo Three &gt; three.txt; # Creating three files
&gt; git add one.txt
&gt; git commit -m "Adds one.txt"
&gt; git add two.txt
&gt; git commit -m "Adds two.txt"
&gt; git add three.txt
&gt; git commit -m "Adds three.txt"
&gt; git log --online

bdb52f3 (HEAD -&gt; master) Adds three.txt
c387fcb Adds two.txt
e99f4bf Adds one.txt</code></pre>
Let's make some changes to a file and commit it.
<pre class="language-bash"><code># Making changes to one.txt
&gt; echo Edited one &gt; one.txt
&gt; git commit -am "Updates one.txt" # Adding and committing directly
&gt; git log --oneline

8b730e8 (HEAD -&gt; master) Updates one.txt
bdb52f3 Adds three.txt
c387fcb Adds two.txt
e99f4bf Adds one.txt</code></pre>
Now let's see how to git undo the last commit.
<h2 style="text-align: center;">4 ways to git undo last commit</h2>
<h3>1. Using git revert</h3>
<code>git revert</code> command does the same as it states, that is it reverts any committed changes. This git command reverts the specified commit and creates a new commit with the reverted changes.&nbsp;
This is the most preferred git command for undoing or reverting any commits because this doesn't delete or orphan any of the commits. In short, this command doesn't rewrite the git history.
Let's see how to undo the commit using <code>git revert</code> command
<pre class="language-bash"><code># Undoing the last commit using git revert
&gt; git revert HEAD</code></pre>
To revert the last commit, we can use HEAD as it points to the last commit or we can use the hash of the commit we want to undo. By running the above command opens the configured editor to change the default message and once you close the editor, the last commit gets reverted with a new commit having "Revert" prefix to the actual commit name.&nbsp;
To avoid the editor from opening you can use <code>--no-edit</code> flag. To avoid committing the changes you can use <code>-n</code> or <code>--no-commit</code> flag as a result the reverted changes will be added to the staging(index) area without committing it.
<pre class="language-bash"><code># Reverting without opening the editor
&gt; git revert --no-edit HEAD

# Reverting without committing the reverted changes
&gt; git revert -n HEAD</code></pre>
Now let's see another way to git undo last commit.
<h3>2. Using git reset&nbsp;</h3>
The git reset is a powerful command using which we can undo a series of previously committed changes. This command orphans the commits by resetting the head to a specified state.
<code>git reset</code> takes the commit hash or reference from HEAD to which it is going to reset to. Once the git reset command is run, there won't be any latest commit logs up to the commit hash.
We can undo the last commit in three different forms with the <code>git reset</code> command. There are three flags that can be used with this command, --soft, --mixed(default), --hard.&nbsp;
On <code>--soft</code> reset, the commit gets removed and the changes get added to the staging area.&nbsp;
On <code>--mixed</code> reset(default), the commit gets removed and the changes get added to the local or working area.&nbsp;
On <code>--hard</code> reset, the commit gets removed and all the changes would be lost.&nbsp;
So based on your requirement you can pick the appropriate flag to undo the last commit.
<pre class="language-bash"><code># Undoing the last commit using git reset
&gt; git reset HEAD^ # points to the commit before the last one

# To completely undo the commit
&gt; git reset --hard HEAD^</code></pre>
Now let's see the third way to undo the last git commit.
<h3>3. Using git restore</h3>
The <code>git restore</code> command is used to restore files in the working directory from the index or from other commits. We can also restore files to the index from other commits.&nbsp;
<code>git restore</code> will not remove the previous commit logs or messages, it just restores the files or the directories as before.
<pre class="language-bash"><code># Restoring the working directory from index
&gt; git restore . # .(dot) means complete directory</code></pre>
The above command just restores everything from the last commit. But what we want is to restore the commit before the last commit.&nbsp;
To restore files from other commits, git restore has <code>--source</code> flag, using that we can restore the parent of the last commit i.e., HEAD~1.
<pre class="language-bash"><code># Undoing the last commit using git restore
&gt; git restore --source=HEAD~1 .</code></pre>
By running the above command, the working directory will be with changes as that of the last commit's parent. It's just like <code>git revert -n HEAD</code> result but all the changes will be in the working directory not in the staging area.&nbsp;
To restore the changes to the staging area just use the <code>--staged</code> flag.&nbsp;
So using <code>git restore</code> command you will have the flexibility to commit changes with any message unlike git revert default message and also you can restore files specifically instead of the whole directory.&nbsp;
And now let's see the fourth way to undo the last git commit.
<h3>4. Using git rebase -i</h3>
The <code>git rebase -i</code> is a very powerful command for rewriting the git history. This command is used for rewording, editing, picking, dropping, squashing, etc commits.&nbsp;
git rebase with interactive flag helps to drop the commits. The same feature we can use to undo the last commit.&nbsp;
To make changes to the commit using <code>rebase -i</code> we need to go(rebase) to the parent of that commit and then make any changes we want.
<pre class="language-bash"><code># Undoing the last commit using git rebase
&gt; git rebase -i HEAD~1 # select d - drop from the menu and proceed
</code></pre>
When you run the above command your default editor gets opened with a list of actions you can perform on the last commit, select <code>d</code> or <code>drop</code> option and proceed. That will remove the last commit from the git log.&nbsp;
And that is how you can undo last git commit using rebase -i.
<h3>Points to note</h3>
<code>git revert</code> and <code>git restore</code> will not modify the git history or log. So when dealing with collaborative works, it's good to use git revert and git restore for undoing the commits. This will help to maintain a clear log of all actions.&nbsp;
<code>git reset</code> and <code>git rebase -i</code> will remove the logs of the commits. You can prefer this when your commits are local but in collaborative cases, you should strictly avoid using these because by chance you may end up rewriting the history of other people's commits.&nbsp;
Those are all the methods one can use to undo git commits. Which method to use depends on the individuals and their work environment.&nbsp;

Here are the 4 ways to git undo last commit in simple and easy steps. You can learn which git commands to use to undo commits effectively.

Posts tagged with Git

4 ways to git undo last commit in simple and easy steps