How to Go Back to a Previous Commit in Git?

Version control is essential in software development, allowing developers to manage changes, track history, and collaborate efficiently. In Git, the ability to revert to a previous commit can be invaluable, especially if you need to discard recent changes, test an older version, or fix a mistake. Understanding the various methods to go back to a previous commit will make it easier to navigate your project’s history and manage your code effectively.

This blog covers several ways to revert to a previous commit, helping you choose the best approach based on your needs.

---

Why Go Back to a Previous Commit?

There are several scenarios where you might want to return to a previous commit:

• Bug Introduction: New changes introduce bugs or errors, and you need to identify or isolate them.
• Testing: You want to test the application or features as they were at a specific point in time.
• Undo Mistakes: Mistakes or unwanted changes need to be discarded to return to a stable version.

Key Methods to Go Back to a Previous Commit

In Git, there are three primary ways to move back to a previous commit:

1. Checkout a Previous Commit
2. Reset to a Previous Commit
3. Revert a Commit

Each method has specific use cases, so let’s look at each one in detail.

---

Method 1: Checkout a Previous Commit (Detached HEAD)

Checking out a previous commit allows you to view and test the project as it was at a specific point in history. However, this action puts you in a detached HEAD state, meaning any changes you make won’t be attached to the current branch.

Steps:

1. Identify the Commit Hash: To find the commit you want to go back to, use the following command:

   git log --oneline

This will display a list of commits with their hashes. Copy the hash of the desired commit.

2. Checkout the Commit:

   git checkout <commit-hash>

Replace <commit-hash> with the hash you copied. This command switches your working directory to the state of that commit, allowing you to explore or test it.

Note: Since you’re in a detached HEAD state, any new commits won’t be saved to your branch. To retain changes made in this state, create a new branch by running:

git checkout -b new-branch-name

---

Method 2: Reset to a Previous Commit

If you want to permanently remove recent commits and move the branch pointer back to an earlier commit, git reset is your best option. There are three types of resets, each with a different impact on your working directory and staging area:

Types of Git Reset

1. Soft Reset: Moves the branch pointer to a previous commit but keeps changes in the staging area, allowing you to recommit them.

   git reset --soft <commit-hash>

2. Mixed Reset (default): Moves the branch pointer to a previous commit and keeps changes in your working directory but removes them from the staging area.

   git reset --mixed <commit-hash>

3. Hard Reset: Moves the branch pointer and completely removes changes from both the staging area and working directory. This option is irreversible, so use it with caution.

   git reset --hard <commit-hash>

Example: To discard the last three commits and return to an earlier stable commit, you can run:

git reset --hard <commit-hash>

When to Use Git Reset

Use git reset when you want to remove recent commits from your branch history. Note: A reset affects only the local repository. If you’ve already pushed these commits to a remote repository, it’s best to avoid git reset as it can cause issues for collaborators.

---

Method 3: Revert a Commit

Git revert is a safe way to undo changes by creating a new commit that undoes the effects of a previous commit. This method preserves the project’s history, making it ideal for undoing changes in a shared repository without rewriting history.

Steps:

1. Identify the Commit Hash: Find the commit you want to revert by running:

   git log --oneline

2. Revert the Commit:

   git revert <commit-hash>

This command creates a new commit that reverses the specified commit’s changes.

3. Push Changes to the Remote Repository:

   git push origin branch-name

Replace branch-name with the name of the branch you’re working on.

When to Use Git Revert

Use git revert when you want to keep a record of all changes and ensure that other collaborators can see the undo operation in the project history.

---

Comparison: Which Method to Choose?

Method	Effect	Use Case
Checkout	Puts the project in a detached HEAD state.	Temporary testing or viewing a previous commit.
Reset	Moves the branch pointer back to a specific commit, optionally removing recent changes.	Rewriting history locally (not for shared repos)
Revert	Creates a new commit that undoes the effects of a specific commit.	Safely undo changes in a shared repository.

---

Practical Examples

Example 1: Temporarily Viewing an Older Version

If you just want to view or test an older commit without making any permanent changes, use checkout:

git checkout <commit-hash>

Example 2: Remove the Last Commit and Keep Changes

To remove the most recent commit but keep changes in your working directory, use a mixed reset:

git reset --mixed HEAD~1

This command moves the branch pointer back by one commit and keeps the file changes.

Example 3: Undo a Specific Commit and Push the Reversion

To undo a specific commit and push the change, use git revert:

git revert <commit-hash>
git push origin branch-name

---

Troubleshooting Common Issues

1. Detached HEAD Warning: If you’re in a detached HEAD state and want to retain changes, create a new branch using git checkout -b new-branch-name.
2. Conflicts During Revert: If there are conflicts while running git revert, resolve them, stage the changes, and complete the commit with git commit.
3. Reverting Multiple Commits: For multiple reverts, use git revert in sequence, or consider using an interactive rebase (git rebase -i) to squash commits and remove them from history.

---

Summary

Going back to a previous commit in Git is a powerful feature that can save you time and effort in managing your project’s history. Whether you use checkout, reset, or revert depends on your specific needs and whether you’re working in a shared repository. By mastering these commands, you’ll have greater flexibility in undoing changes, testing older versions, and collaborating effectively within your team.

Each approach serves a unique purpose, and understanding their differences will help you make the right choice for every scenario.