Resolving Incorrect Branch Work in Git: Safely Migrating Changes to a Target Branch

Problem Context and Core Challenge

In daily use of the distributed version control system Git, developers may inadvertently make code modifications on the wrong branch. For instance, instead of working on a topic branch named branch123 for a new feature, changes are made to three files on the master branch. Committing directly to master could contaminate its clean history with untested changes or disrupt stability. Thus, the core challenge is to safely and non-destructively migrate these uncommitted changes to the target branch while preserving the original state of master.

Best-Practice Solution: Migration Workflow Based on Git Stash

According to the community-accepted best answer, an efficient and secure solution involves three key Git commands: git stash, git checkout, and git stash apply. This combination leverages Git's stashing mechanism to temporarily save the working directory state without committing changes.

First, execute git stash on the master branch. This command saves all uncommitted changes (including staged and unstaged modifications) to a special storage area and resets the working directory to the last commit state. In principle, git stash creates a new commit object that records differences between the current working directory and index, but does not add it to branch history. For example, if three files are modified, run:

git stash

The output might show something like Saved working directory and index state WIP on master: abc1234 Initial commit, indicating the changes are stashed.

Next, use git checkout branch123 to switch to the target branch. This updates the working directory to match the latest commit on branch123, ensuring subsequent operations occur in the correct context. If branch123 does not exist, create and switch with git checkout -b branch123.

Finally, run git stash apply to restore the stashed changes to the current branch. This command retrieves changes from storage without automatically deleting the stash entry, allowing developers to reapply or inspect as needed. For example:

git stash apply

At this point, the three files modified on master should appear in the working directory of branch123, ready for normal commit operations.

Technical Details and Internal Mechanism Analysis

A deeper understanding requires exploring Git's underlying mechanisms. The git stash command performs two actions: it creates a commit containing differences between the working directory and index, and it uses git reset --hard to reset the working directory. Stash entries are stored as references in .git/refs/stash and can be viewed with git stash list. When applying a stash, Git attempts to merge changes; conflicts require manual resolution.

A key advantage is that this workflow entirely avoids committing anything to master, maintaining its linear and clean history. In contrast, using git commit followed by git cherry-pick would leave unnecessary commit records on master, increasing maintenance complexity.

Potential Risks and Alternative Methods

While the above solution works in most cases, developers should be aware of potential risks. For example, if stashed changes conflict with existing code on the target branch, git stash apply might fail, necessitating manual conflict resolution. Additionally, stash entries are not shared across branches by default, and accidental deletion could lead to loss of changes.

As a supplement, alternative methods include using git diff and git apply in combination:

git diff > changes.patch
git checkout branch123
git apply changes.patch

This approach saves changes as a patch file, offering a more visual backup, but may not handle complex renames or binary files well.

Conclusion and Best Practice Recommendations

In summary, the combination of git stash, git checkout, and git stash apply enables efficient and safe migration of changes from an incorrect branch to the target branch. It is advisable to develop habits of checking the current branch before frequent switches and using git status to confirm state. For team projects, integrating branch protection policies and code review processes can further mitigate such errors.