How to stash one of multiple changed files on branch

In Git, stashing changes is a useful way to save modifications temporarily without committing them, allowing you to work on a clean slate or switch branches. When you have multiple changed files but want to stash only one, you can achieve this by using the git stash push command with the --patch or -p option, which allows you to interactively select the changes to stash. This approach provides flexibility and precision in managing your stashes, ensuring only the specified changes are stashed while the rest remain in your working directory.

Using git stash push --patch

Interactive Stashing:
To stash changes from a specific file interactively, use the git stash push --patch command. This option lets you review each change and decide whether to stash it.

git stash push -p

How It Works:

• Prompt: Git will prompt you for each change in your working directory.
• Selection: You can choose to stash or skip changes on a per-hunk basis.
• Precision: Ensures only the selected changes are stashed, leaving other modifications intact.

Steps:

1. Run git stash push -p.
2. Follow the prompts to stash changes from the specific file.
3. Skip changes from other files by pressing n when prompted.

Stashing Specific Files

Direct File Stashing:
To stash changes from a specific file directly without interactive prompts, specify the file path with the git stash push command.

git stash push -m "Stashing specific file" path/to/your/file

Explanation:

• Command: git stash push stashes changes.
• Message: -m "message" adds a description to the stash.
• File Path: path/to/your/file specifies the file whose changes should be stashed.

Benefits:

• Simplicity: Directly stashes changes from the specified file.
• Efficiency: No need for interactive selection.

Verifying Stashed Changes

List Stashes:
After stashing changes, verify the stashed changes using git stash list.

git stash list

Details:

• Output: Shows a list of stashes with descriptions.
• Identification: Helps identify the specific stash created for the file.

Example:

stash@{0}: On master: Stashing specific file

Inspecting Stash:
To see the details of a specific stash, use git stash show.

git stash show stash@{0}

Benefits:

• Verification: Ensures the correct changes were stashed.
• Confirmation: Confirms the stash contents before applying or dropping it.

Applying and Dropping Stashes

Applying a Stash:
To apply the stashed changes back to your working directory, use git stash apply.

git stash apply stash@{0}

Steps:

1. Identify the stash using git stash list.
2. Apply the stash using git stash apply stash@{n}.

Dropping a Stash:
After applying or if the stash is no longer needed, remove it using git stash drop.

git stash drop stash@{0}

Benefits:

• Cleanup: Keeps your stash list manageable by removing unnecessary stashes.
• Efficiency: Ensures only relevant stashes are retained.

Handling Merge Conflicts

Conflicts During Apply:
If applying a stash results in conflicts, resolve them manually.

Steps:

1. Apply the stash: git stash apply stash@{0}.
2. Resolve conflicts using standard Git conflict resolution methods.
3. Stage resolved changes: git add ..
4. Complete the process: git commit (if necessary).

Tips:

• Conflict Markers: Look for conflict markers (<<<<<<>>>>>>) in files.
• Tools: Use merge tools like git mergetool for assistance.

Benefits:

• Control: Manually resolving conflicts ensures the correct integration of changes.
• Flexibility: Allows for careful consideration of conflicting changes.

Best Practices for Stashing

Naming Stashes:
Use meaningful messages with the -m option to describe stashes.

Example:

git stash push -m "WIP: Stashing changes from fileA for bug fix" path/to/fileA

Organizing Stashes:

• Regular Cleanup: Periodically review and drop unnecessary stashes.
• Documentation: Maintain a log of important stashes and their purposes.

Benefits:

• Clarity: Clear descriptions make it easier to identify stashes later.
• Efficiency: Organized stashes facilitate quick access and management.

Advanced Techniques

Partial Stashing:
Combine --patch with specific file paths for granular control.

git stash push -p path/to/fileA

Selective Stashing:
Use the git add -p command to stage specific changes, then stash staged changes.

git add -p path/to/fileA
git stash push -m "Stashing specific hunks from fileA"

Explanation:

• Staging: git add -p interactively stages changes.
• Stashing: git stash push stashes only staged changes.

Benefits:

• Granularity: Fine-tuned control over what gets stashed.
• Flexibility: Combine staging and stashing for complex scenarios.

Summary

Stashing specific files or changes in Git is a powerful technique to manage your working directory without committing incomplete work. By using git stash push --patch or specifying file paths directly, you can selectively stash changes, maintaining a clean and organized workflow. These methods, combined with best practices and advanced techniques, provide flexibility and precision in handling stashes, ensuring efficient and effective project management.