How to Revert a Previous Commit in Git?

Reverting a previous commit is a common requirement when working with Git, whether to fix a mistake, remove unwanted changes, or restore a previous state in a project. Git provides powerful tools for undoing changes, with different options depending on your need to either keep, discard, or amend history.

In this guide, we’ll cover several methods to revert a commit in Git, explain when to use each method, and give practical examples to help you manage your code effectively.

---

Why Revert a Commit?

Reverting a commit might be necessary when:

• An Error Was Made: A mistake in code needs correction, or unintended changes were committed.
• New Requirements: A feature or change is no longer needed, and you want to remove it from the codebase.
• Collaboration Requirements: When working with others, you may need to adjust your changes to keep the codebase synchronized.

---

Methods to Revert a Commit in Git

There are several ways to undo a commit in Git, depending on whether you want to keep the changes made in that commit or discard them entirely.

---

Method 1: Using git revert to Keep History Intact

The git revert command creates a new commit that undoes the changes made by a previous commit. This is ideal when you need to preserve the commit history without altering it, making it the preferred option in shared or public repositories.

Step-by-Step Guide to Using git revert

1. Identify the Commit You Want to Revert:

• Run git log to list your recent commits and find the commit hash (ID) of the commit you want to revert. git log
• Copy the hash of the commit you want to revert.

1. Run the git revert Command:

• Use git revert followed by the commit hash: git revert COMMIT_HASH
• Replace COMMIT_HASH with the actual commit ID you copied.

1. Resolve Merge Conflicts (If Any):

• If the commit conflicts with your current code, Git will notify you, and you’ll need to resolve the conflicts before finalizing the revert. After resolving conflicts, use: git add . git revert --continue

1. Commit and Push the Revert:

• After a successful revert, commit the changes (if they’re not already committed) and push them to your remote branch: git push origin main This method keeps your commit history clean and transparent, which is often ideal for collaboration.

---

Method 2: Using git reset to Move Backward in History

If you want to discard recent commits and revert to a specific state, git reset is a more direct approach. However, use caution with this command in shared repositories, as it changes commit history and can disrupt others’ work.

Step-by-Step Guide to Using git reset

1. Identify the Target Commit:

• Use git log to find the commit you want to reset to.

1. Choose the Reset Mode:

• Git provides several reset modes. Here are the most commonly used:
  • --soft: Moves the HEAD pointer to the target commit but keeps all changes staged, so you can recommit them.
  • --mixed: Moves the HEAD pointer to the target commit and unstages the changes, but keeps them in the working directory.
  • --hard: Discards all changes, making your working directory match the target commit exactly. Be cautious with this option, as it permanently deletes changes.

1. Run the git reset Command:

• For example, if you want to reset to a specific commit with --soft: git reset --soft COMMIT_HASH
• Replace COMMIT_HASH with the commit ID you copied.

1. Recommit or Push the Changes (Optional):

• If you used --soft or --mixed, you’ll still have the changes in your working directory and can make any necessary adjustments. To push the changes to GitHub, use: git commit -m "Adjust commits after reset" git push --force origin main

---

Method 3: Using git checkout for Temporary Reversions

git checkout is useful if you want to view or use a previous commit temporarily. However, it’s typically replaced with git switch for checking out branches, so this method is more for navigating history than permanently undoing changes.

1. Identify the Commit to Check Out:

• Use git log to find the commit hash.

1. Run git checkout:

• Use git checkout with the commit hash: git checkout COMMIT_HASH
• This command moves you to a “detached HEAD” state, allowing you to explore the code from that commit without altering the main branch.

Note: This change isn’t permanent. If you want to keep changes based on this commit, create a new branch and make commits there.

---

Method 4: Using git reflog to Revert to Any State

If you need to revert your branch to a state that isn’t immediately visible in git log, git reflog is a powerful tool. It tracks every movement of your HEAD, allowing you to revert to any previous state, even if it was overwritten by reset commands.

Step-by-Step Guide to Using git reflog

1. View the History of HEAD:

• Run git reflog to see a detailed list of your recent HEAD states: git reflog

1. Identify the Desired State:

• Locate the commit you want to revert to and copy its hash.

1. Reset to the Target Commit:

• Use git reset to move to the chosen commit: git reset --hard COMMIT_HASH git reflog can be invaluable when you need to retrieve a commit that might not be in your current history due to resets or branch changes.

---

Summary: Choosing the Right Method to Revert a Commit

Each of these methods has specific uses depending on your needs:

1. git revert: Ideal for collaborative work where preserving history is essential.
2. git reset: Useful for discarding recent commits or staging them for recommitment. Use with caution in shared repositories.
3. git checkout: Allows you to view previous commits temporarily without altering the main branch.
4. git reflog: Provides a powerful way to restore commits that might be hidden from git log.

---

Best Practices for Reverting Commits in Git

• Communicate with Your Team: If you’re reverting commits on a shared branch, notify team members to prevent conflicts.
• Use Descriptive Commit Messages: When creating a revert commit, make the reason clear in the commit message.
• Avoid Force-Pushing: Only use --force when absolutely necessary, as it can overwrite others’ work in a shared repository.
• Test Locally Before Pushing: Test changes in your local environment before pushing them to the remote repository, especially after a reset or revert.

---

Conclusion

Reverting commits in Git is straightforward once you understand the available tools and their applications. Whether you’re collaborating on a large project or working on a solo venture, knowing how to undo changes and restore previous states is essential for effective version control.

Using these techniques, you can confidently manage your Git history and adjust to new project requirements without losing track of your changes.