Rewriting Git History: Deleting or Merging Commits with Interactive Rebase

Core Mechanism of Git History Modification

In the Git version control system, commit history is typically considered immutable. However, in certain development scenarios, developers may need to modify historical records, such as deleting commits containing sensitive information or erroneous code. Git provides history rewriting capabilities through the rebase command, with interactive rebasing (git rebase -i) being the key tool for fine-grained control.

Basic Operations of Interactive Rebase

To modify recent commit history, first determine the scope of operation. Using the git rebase -i HEAD~N command opens an interactive editor displaying a list of the last N commits. Each commit is preceded by a pick instruction, indicating it will be kept. By modifying these instructions, different history rewriting effects can be achieved.

Comparison of Commit Deletion Strategies

There are three main methods for completely removing commits from history:

1. Commenting Out Method: In the interactive editor, comment out the lines corresponding to commits to be deleted (by adding a # at the beginning). This approach is straightforward but may not be formally supported in some Git versions.
2. Squash Merging Method: Merge multiple commits into a single new commit. Using the squash instruction merges the content of specified commits into the previous commit. This method does not completely delete commit records but integrates their content, suitable for cleaning up intermediate steps while preserving final changes.
3. Direct Deletion Method: Newer Git versions support the drop instruction to directly delete specified commits. This approach most closely matches the semantics of "complete deletion" but requires Git version 2.21.0 or higher.

Detailed Operation Example

Assume the current Git history is as follows:

>git log --pretty=oneline --abbrev-commit
2f05aba Added new feature
3371cec Fixed screw up
daed25c Screw up
e2b2a84 First commit

To delete the middle two commits (3371cec and daed25c) as if they never happened, follow these steps:

1. Run git rebase -i HEAD~4 to open the interactive editor.
2. The editor will display four commits, each starting with pick. Change pick to drop for the lines to be deleted (or comment them out).
3. After saving and closing the editor, Git will reapply the remaining commits, skipping the deleted ones.

Example of modified instruction list:

pick 2f05aba Added new feature
drop 3371cec Fixed screw up
drop daed25c Screw up
pick e2b2a84 First commit

Alternative Approach: Squash Merging

If complete deletion is not desired, but rather merging commits into a cleaner history, use the squash instruction. For example, merging the two problematic commits into the first commit:

pick 2f05aba Added new feature
squash 3371cec Fixed screw up
squash daed25c Screw up
pick e2b2a84 First commit

After execution, Git creates a new commit containing all changes from the three commits and allows editing of the final commit message.

Precautions and Risk Management

History rewriting operations change commit hashes and can significantly impact collaborative projects:

• Local Operation Principle: Only rewrite history for commits not yet pushed to remote repositories.
• Branch Protection: If commits have been pushed to shared branches, force pushing (git push --force) may overwrite others' work and should be avoided.
• Backup Strategy: Before operations, create a backup branch using git branch backup-branch to prevent mistakes.
• Conflict Resolution: Conflicts may arise during rebasing and require manual resolution to continue.

Version Compatibility Considerations

Different Git versions vary in their support for interactive rebasing. Older versions may not support the drop instruction, in which case the commenting out method can serve as an alternative. It is recommended to confirm version information via git version before use and select appropriate methods based on team environment.

Conclusion

Git's interactive rebase provides developers with flexible history modification capabilities, but must be used cautiously. In personal development branches, judicious use of commit deletion or merging can maintain clear history; in collaborative environments, non-destructive history organization methods should be prioritized. Mastering these techniques not only enhances individual development efficiency but also helps maintain long-term project maintainability.