Git Revert Command Detailed Explanation

When working with Git, developers often need to make changes and commit them to the repository. However, sometimes we may make changes that are not desirable or cause issues in the project. In such cases, we need to undo our changes and revert to a previous state of the repository. This is where the Git revert command comes into play.

In this article, we will take a closer look at the Git revert command, its different use cases, and how to use it effectively.

What is the Git Revert Command?

The Git revert command is used to undo changes made to a particular commit or a set of commits by creating a new commit that effectively reverses the changes. This means that the existing branch will be updated with a new commit that reverts the changes made in a previous commit, effectively bringing the repository back to a previous state.

Unlike the reset command, the revert command creates a new commit, which keeps the complete history of the project intact. This is a crucial feature in collaborative projects, as it allows us to undo changes without affecting other developers working on the same codebase.

How to Use Git Revert Command?

Let’s take a look at the different use cases of the Git revert command and how to use it effectively.

Revert a Single Commit

The most common use case of the revert command is to undo changes made in a single commit. To do so, we need to execute the following command:

git revert <commit-hash>

Here, <commit-hash> is the hash of the commit we want to revert. For example, if we want to revert the commit with the hash 1a2b3c, we need to execute the following command:

git revert 1a2b3c

This command will create a new commit that undoes the changes made in the 1a2b3c commit, effectively bringing the project back to its previous state.

Revert Multiple Commits

We can also use the revert command to undo changes made in multiple commits. To do so, we can give multiple commit hashes as parameters to the revert command, like so:

git revert <commit-hash-1> <commit-hash-2> <commit-hash-3> ...

This will create a new commit that effectively undoes the changes made in all the specified commits, bringing the repository to a previous state.

Resolve Conflicts

When using the revert command, Git creates a new commit that undoes the changes made in the target commit(s). However, there might be situations where some changes conflict with the current state of the repository.

In such cases, Git will display a message asking us to resolve the conflicts manually. We need to modify the files with conflicts, mark them as resolved, and then commit the changes to complete the revert process.

Revert Multiple Commits and Merge

The revert command can also be used to undo multiple commits while preserving other changes made in between them. This is especially useful when we need to undo a specific set of changes but keep other changes made in the repository.

To achieve this, we need to specify the commit range that we want to revert. For example, if we want to revert the changes made in commit-hash-1, commit-hash-2, and commit-hash-3, but keep the changes made in between them, we can execute the following command:

git revert -n <commit-hash-3>.. <commit-hash-1>

Here, -n flag tells Git to perform the revert but don’t commit the changes immediately. We can then manually resolve the conflicts (if any) and commit the changes.

Revert Merge Commits

Last but not least, we can use the revert command to undo merge commits. Merge commits are created when we merge two branches into one. In some cases, we might want to undo the merge commit and bring the repository back to a previous state.

To do so, we need to execute the following command:

git revert -m <parent-number> <merge-commit-hash>

Here, <parent-number> specifies the parent to keep when undoing the merge commit (usually 1 or 2), and <merge-commit-hash> is the hash of the merge commit that we want to revert.

Conclusion

The Git revert command is a powerful feature that allows us to undo changes made to a particular commit or a set of commits while keeping the complete history of the project intact. We can use it to handle various use cases, such as reverting single or multiple commits, resolving conflicts, reverting merge commits, and more.

Knowing how to use the revert command effectively is crucial for any Git user, as it can save a lot of time and effort in handling complex codebases. With this knowledge, we can confidently handle any changes and effectively collaborate with other developers on our projects.