Git is a powerful version control system that allows developers to track and manage changes to their codebase. However, sometimes we make mistakes and need to undo or redo a commit. In this article, we will explain how to undo a commit and redo it using Git’s reset and commit commands.
First, let’s understand what happens when we make a commit in Git. A commit is a snapshot of our codebase at a particular point in time. It captures the changes we have made to the code, along with a message that describes the purpose of the commit. When we make a commit, Git stores this snapshot in its history, and we can refer to it later if we need to.
Now, let’s say we make a commit and later realize that it was a mistake. We can use the git reset command to undo the commit and return our codebase to the state it was in before the commit. The git reset command has the following syntax:
git reset HEAD~
HEAD~ argument specifies the commit that we want to undo.
In this case, it means the most recent commit.
If we want to undo a different commit, we can specify its
SHA-1 hash instead of
After we run the git reset command, our codebase will be returned to the state it was in before the commit, but the changes we made will still be present in our working tree (the state of our files on disk). This means that we will need to make any necessary corrections to the code and add the changes again before we can commit them again.
Once we have made the necessary changes, we can use the git add command to stage the changes for the next commit:
git add .
. argument specifies that we want to stage all changes in the current directory and its subdirectories.
Alternatively, we can specify individual files or directories that we want to stage.
Now that the changes are staged, we can use the git commit command to commit them again,
git commit -c ORIG_HEAD
-c option specifies that we want to reuse the old commit message,
but we can also use the
-m option to specify a new commit message directly.
Alternatively, if we only want to change the commit message of the previous commit, we can use the git commit –amend command instead. This will add the changes we have staged to the previous commit, and allow us to edit the commit message in an editor.
In addition to undoing and redoing a commit, there may be times when we need to remove a commit that has already been pushed to the server. This is known as rewriting history, and it can be dangerous because it changes the history of the codebase and may cause conflicts with other developers who have also pushed changes to the server.
To remove a commit that has been pushed to the server, we can use the
git push command with the
--force-with-lease option. For example:
git push origin main --force
origin argument specifies the remote repository, and the main argument specifies the branch
to which we want to push the changes.
--force option tells Git to overwrite the remote branch with our local branch, regardless of any conflicts or differences.
It’s important to note that using the
--force option can be dangerous,
as it can cause data loss if other developers have pushed changes to the same branch.
For this reason, it’s generally better to use the
which will only overwrite the remote branch if it hasn’t been changed since we last pulled from it.
To determine the
SHA-1 hash of the commit that we want to remove,
we can use the
git reflog command, which displays a log of all the changes that have been made to the local repository.
Once we have the
SHA-1 hash, we can use it in the
git reset and
git push commands as described above.
In conclusion, Git’s reset and push commands allow us to undo and redo commits, as well as remove commits that have already been pushed to the server. While these commands can be powerful, they can also be dangerous if used improperly, so it’s important to understand their implications and use them with caution.