How to Delete a Previous Commit in Git?

Git is an incredibly powerful version control system, but sometimes mistakes happen, and you may need to delete a previous commit. Whether you made an error, committed sensitive information, or simply need to reorganize your commit history, Git provides several ways to remove or undo commits.

In this blog, we’ll guide you through the process of deleting or undoing a previous commit safely.

Important Considerations Before Deleting a Commit

1. Understand the Impact: Deleting a commit alters your repository’s history. This can have unintended consequences, especially if the commit has already been pushed to a remote repository.
2. Coordinate with Your Team: If you’re working in a team, communicate with your collaborators before modifying shared commit history.
3. Backup Your Work: Before making significant changes, consider creating a backup of your repository.

Scenarios for Deleting a Commit

• Delete the Most Recent Commit (Local)
• Delete a Commit from History (Any Commit)
• Remove a Commit from a Remote Repository

Case 1: Delete the Most Recent Commit

If you want to delete the latest commit and keep your changes as unstaged files:

1. Run the following command: git reset --soft HEAD~1
   • HEAD~1 refers to the most recent commit.
   • The --soft option keeps your changes in the staging area.
2. If you want to discard the changes entirely: git reset --hard HEAD~1
   • This will delete the commit and discard all changes made in it.

Case 2: Delete a Specific Commit from History

If you need to delete a commit that is not the most recent one, you can use an interactive rebase:

1. Start an interactive rebase: git rebase -i HEAD~n Replace n with the number of commits you want to go back. For example, if you want to edit the last 5 commits: git rebase -i HEAD~5
2. In the editor that opens, you’ll see a list of commits, like this: pick abc123 Commit message 1 pick def456 Commit message 2 pick ghi789 Commit message 3
3. Change pick to drop for the commit you want to delete: pick abc123 Commit message 1 drop def456 Commit message 2 pick ghi789 Commit message 3
4. Save and close the editor. Git will rewrite your commit history without the dropped commit.

Case 3: Remove a Commit from a Remote Repository

If you’ve already pushed the commit to a remote repository, deleting it requires additional steps:

1. Use git reset or git rebase locally to delete the commit (as shown above).
2. Force push the changes to the remote repository: git push origin branch-name --force
   • Replace branch-name with the name of your branch.
   • Warning: Force pushing overwrites the remote branch and can disrupt work for others. Ensure all collaborators are informed.

Case 4: Delete a Commit That Contains Sensitive Data

If your commit contains sensitive data like passwords or API keys, simply deleting the commit may not remove the data from the repository’s history. Use the git filter-repo tool for complete removal:

1. Install git-filter-repo: pip install git-filter-repo
2. Remove the commit: git filter-repo --path <file-path-to-remove>
3. Force push the changes to update the remote repository: git push origin branch-name --force

Best Practices When Deleting Commits

1. Avoid Force Push in Shared Repositories: If possible, use non-destructive methods to manage commits.
2. Amend Instead of Delete: If you need to modify the most recent commit, consider amending it: git commit --amend
3. Use Staging and Testing: Prevent problematic commits by thoroughly testing and reviewing changes before committing.

Common Errors and Solutions

Error: “Cannot rebase while uncommitted changes are present”

• Cause: You have uncommitted changes.
• Solution: Stash or commit your changes before rebasing: git stash

Error: “Rejected by remote due to non-fast-forward updates”

• Cause: Trying to push changes without force pushing.
• Solution: Use --force cautiously to overwrite the remote history.

Conclusion

Deleting a commit in Git is a powerful operation that should be used judiciously. By understanding the scenarios and commands outlined in this guide, you can effectively manage your repository’s history while minimizing risks. Remember to coordinate with your team and always have a backup plan when making significant changes.