JIYIK CN >

Sometimes, we need to merge two or more branches and then push the commit to the desired branch. But later we realize that we don’t need the merge in that repository, so the question here is how to undo or revert the merge commit that has already been pushed. There is nothing to worry about. Git has a great solution for this problem which we will discuss below.

There are two ways to handle this situation, depending on the problem; one is that it has not been pushed to the repository but has been committed. The other is that it has been committed and pushed to the repository. Both cases are discussed below:

Undoing unpushed Git commits

It is not possible to revert a commit directly in Git. Nevertheless, we need to check the commit before reverting. After reverting, the location of the working directory is now the same as the location of the working directory before we pushed the commit.

We can now apply git resetthe command to move the index pointer back to where it was before the commit. For example, if we want to keep the changes from commits Commit1and Commite3, but revert Commit2the changes from commit , execute this command.

git reset HEAD~3

This command will return the index pointer to Commit2where it was before the commit. After reverting the commit, we need to add the changed files to the working directory again. For example, execute the following command:

git checkout Commit1 
git add Commit1  
git checkout Commit3 
git add Commit3
git commit

Afterwards, we can push commits Commit1and Commit3to the remote repository.

git push

If we want to merge two branches and then revert the changes from one branch, we can use the following command:

git merge --abort

This command is used to cancel the merge process. Afterwards, we can revert the changes to the branch. The commands discussed in this section are useful if we want to undo the effects of the last commit or multiple commits.

However, if we want to undo the effects of the last two or more commits, we need to reset the working directory to the state before the last commit. This is because it is not possible to directly revert one or more commits.

Reverting a pushed Git commit

In another case, if we have already pushed the merge commit to the remote branch and also pushed it, we have to make a new commit to revert the changes. We will execute the following command:

git revert -m 1 <merge-commit-hash>

This will develop a new commit that will reverse the changes of the previous merge commit. However, this new commit will also contain all the changes of the original merge commit, so we need to edit the commit message to indicate that this is a revert commit. The options we mentioned -m 1will tell Git that we want to keep the merged branch.

revert commandThe revert command does not alter the working tree. It only modifies the index. revert commandIt also has an option to restore the original message of the commit. In the example given above, -mthe revert option is used to restore the original message of the commit. The revert command can also be used to restore specific files from an integrated commit.

Git is a useful tool to use on our local branches when we make changes and decide that we no longer want to keep that change. revertIt is not recommended to use on public branches.

As we all know, git revert is completely reversible and it is impossible to undo its changes. If we perform git revert on a commit that is not the current commit on its branch, we have to be very careful because git revert will develop a new commit with a new commit ID.

If we later do a git reset --hard to revert the changes made by git revert, we will also remove the changes made by the developer who created the commit that git revert undoes. It is possible to use git revert on a public branch, but according to my opinion, it is not a good idea to do so. It is better to develop a new branch to make the changes and then merge it into masterthe branch when you are done.

If we want to use git revert on a public branch, make sure we are the only ones working on that branch, otherwise we will undo everyone else's work.