Complete Guide to Switching Git Branches Without Losing Local Changes

Problem Scenario Analysis

In daily development work, developers frequently encounter the dilemma of realizing that extensive code modifications made on one branch should actually be committed to a different branch. Traditional git checkout commands force developers to either commit or discard current changes, creating workflow inefficiencies. This paper systematically introduces multiple solutions, ranging from simplest cases to most complex scenarios.

Basic Solution: New Branch Creation

When the target branch doesn't exist yet, the solution is most straightforward. Using git checkout -b <branch-name> command creates a new branch based on current working directory state:

$ git status
On branch master
Changes not staged for commit:
  modified:   src/main.js
  modified:   src/utils.js

$ git checkout -b develop
Switched to a new branch 'develop'

$ git add .
$ git commit -m "Implement new feature module"

This approach is suitable for early feature development stages, when developers realize current modifications should belong to a new feature branch. The new branch will contain all uncommitted changes, ready for immediate commit operations.

Core Solution: In-depth Application of git stash

When the target branch already exists, the git stash command becomes the most commonly used solution. This command works by saving working directory and staging area modifications to a special storage area:

Basic Stash Usage Workflow

# Save current modifications to stash
$ git stash push -m "Temporary save for feature development"
Saved working directory and index state On master: Temporary save for feature development

# Switch to target branch
$ git checkout develop
Switched to branch 'develop'

# Apply modifications from stash
$ git stash apply
# Or use pop command to apply and delete stash simultaneously
$ git stash pop

Internal Mechanism of Stash

git stash actually creates two special commits: one for saving working directory modifications, another for staging area contents. These commits don't belong to any branch but are permanently stored in the repository's reflog. Understanding this mechanism helps recover lost stash contents in emergency situations.

Best Practices for Safe Operations

Although git stash pop provides convenient one-step operation, we recommend using separate apply and drop workflow:

$ git stash apply
# Carefully inspect merge results
$ git diff
$ git status

# Delete stash after confirmation
$ git stash drop

The advantage of this method is that if stash application produces unexpected results, developers can reattempt application or select different stash entries without permanently losing original modifications.

Advanced Scenarios and Potential Issues

Merge Conflict Resolution

When conflicts exist between stash modifications and target branch, Git pauses the merge process and requires manual resolution:

$ git stash apply
Auto-merging src/main.js
CONFLICT (content): Merge conflict in src/main.js

At this point, developers need to manually edit conflict files using standard conflict resolution markers (<<<<<<<, =======, >>>>>>>) to determine final content. After resolution, execute git add to mark conflicts as resolved.

Selective Stash Application

For complex modification sets, use git stash push -p for interactive selection, saving only specific modifications:

$ git stash push -p
# Git will prompt for each modification chunk whether to save to stash

Branch Management Strategies in Team Collaboration Environments

Referencing the team collaboration scenario mentioned in supplementary materials, proper branch strategies can significantly reduce occurrences of modifications on wrong branches:

Environment Isolation Branch Model

Establish clear branch correspondences: master for production environment, develop for integration testing, feature/* for feature development. This separation ensures unfinished code doesn't accidentally reach production environment.

Automated Process Integration

Integrating with CI/CD pipelines enables automated checks to prevent pushing code to wrong branches. For example, validate in pre-push hooks whether current branch permits specific types of modifications.

Alternative Approach Comparison

Temporary Commit Method

Another approach involves committing modifications on current branch first, then switching to target branch and using git cherry-pick:

$ git add .
$ git commit -m "Temporary save"
$ git checkout develop
$ git cherry-pick master

This method suits scenarios with substantial modifications requiring preservation of complete commit history.

Working Directory Copy

Although not recommended, in extreme cases developers can manually copy modified files, reset working directory, then restore in new branch. This approach is error-prone and cannot handle complex refactoring modifications.

Conclusion and Best Practices

By systematically mastering git stash and related tools, developers can elegantly handle local modifications during branch switching. Key takeaways include: understanding stash internal mechanisms, adopting safe apply-drop separation workflow, mastering conflict resolution methods, and establishing clear branch strategies in team environments. These skills not only enhance individual development efficiency but also establish solid foundations for team collaboration.