Complete Guide to Deleting Git Commits While Keeping Changes

Problem Scenario Analysis

During software development, developers frequently need to switch between different branches. As described in the Q&A data, when working on a feature branch with code modifications, developers may need to temporarily switch to the main branch for demonstrations. To prevent working directory changes from affecting main branch functionality, developers often choose to commit changes as temporary commits, then need to remove these temporary commits while preserving all changes after the demonstration.

Core Solution: git reset Command

Git provides powerful version control capabilities, with the git reset command being the key tool for handling such scenarios. The basic syntax allows developers to move the HEAD pointer to a specified commit while controlling the impact on working directory and staging area.

Basic Command Analysis

The most straightforward solution is using the command:

git reset HEAD^

This command moves the HEAD pointer to the parent commit of the current commit, effectively deleting the most recent commit. By default (without --hard or --soft parameters), this operation preserves all changes in both working directory and staging area, which is exactly what the Q&A scenario requires.

Special Character Handling

In certain shell environments, the ^ character may be interpreted as a special character. For example, in Windows command line or ZSH with globbing enabled, quotes or alternative syntax are needed:

git reset "HEAD^"
# or
git reset HEAD~1

HEAD~1 means moving back one commit, which has the same effect as HEAD^ in most cases but avoids special character parsing issues.

Alternative Approach: git commit --amend

Another handling method is to continue development and then use commit amendment during the next commit:

git commit --amend [-m "new commit message"]

This command merges current staged changes with the most recent commit, forming a new commit that replaces the original temporary commit. This method is suitable for scenarios where developers want to continue working immediately rather than rolling back.

Comparison of Different Reset Modes

According to reference article analysis, the git reset command has three main modes suitable for different scenarios:

--soft Mode

git reset --soft HEAD~1 moves HEAD to the specified commit but preserves all changes in the staging area. This means all previously staged files remain staged, allowing developers to proceed directly with new commits.

Default Mode (mixed)

git reset HEAD~1 (equivalent to git reset --mixed HEAD~1) moves HEAD to the specified commit while resetting the staging area but preserving all working directory changes. This is the most commonly used mode, suitable for scenarios requiring reorganization of commit content.

--hard Mode

git reset --hard HEAD~1 completely removes the specified commit and all its changes, fully resetting both working directory and staging area to the state of the specified commit. This operation is destructive and should be used with caution.

Practical Application Example

Assume a developer has the following commit history:

commit d78f32b (HEAD -> feature-branch) "temporary commit"
commit 1a6fd59 "previous normal commit"

After executing git reset HEAD^:

• HEAD pointer moves to commit 1a6fd59
• Temporary commit d78f32b is removed from history
• All changes from the temporary commit remain in working directory
• Developer can reorganize these changes and make appropriate commits

Considerations and Best Practices

Handling Pushed Commits

If the temporary commit has already been pushed to a remote repository, using git reset will cause problems as it rewrites history. In such cases, git revert should be used to create new reversal commits:

git revert <commit_hash> --no-edit

Backup and Recovery

Before performing any reset operations, it's recommended to:

• Check current status using git status
• Confirm commit history using git log --oneline
• Understand git reflog usage for recovery in case of operational errors

Workflow Optimization

To avoid frequent occurrences of temporary commits, developers can:

• Use git stash to temporarily save unfinished work
• Plan branch strategies properly to reduce frequency of branch switching
• Use feature branches for development while maintaining main branch stability

Conclusion

Git provides flexible tools to handle various version control needs. git reset HEAD^ or git reset HEAD~1 are effective methods for deleting recent commits while preserving changes, while git commit --amend offers an alternative solution. Understanding the different modes and application scenarios of these commands helps developers manage code versions more efficiently and avoid unnecessary work loss. In practical development, combining team workflows and project requirements to choose the most suitable method for handling temporary commit scenarios is essential.