Extract Single File from Git Stash Without Popping

You can extract a single file from a git stash without popping the entire stash by using git stash show to see the stash contents, then applying the specific file changes using git checkout with the stash reference, or by creating a patch file with git stash show and applying it selectively. The most straightforward approach is to use git checkout stash@{<n>} -- <file> to extract just that single file while keeping the stash intact.

Contents

• Understanding Git Stash Structure
• Method 1: Using Git Checkout with Stash Reference
• Method 2: Creating and Applying a Patch File
• Method 3: Using Git Apply with Stash Output
• Method 4: Pop and Reset (Temporary Approach)
• Best Practices and Common Mistakes
• Alternative Solutions

Understanding Git Stash Structure

Before extracting files from a stash, it’s essential to understand how Git stores stashes. Each stash is essentially a commit-like object that contains:

• The staged changes
• The unstaged changes
• A reference to the original commit

When you run git stash, Git creates a new stash object and updates the stash list. Stashes are stored in a stack-like structure, where the most recent stash is stash@{0}.

Important: Unlike commits, stashes don’t automatically get garbage collected. They remain in your repository until you explicitly remove them with git stash drop or git stash clear.

To see what’s in your stashes, use:

git stash list

To see the contents of a specific stash:

git stash show stash@{<n>}

Method 1: Using Git Checkout with Stash Reference

This is the most direct and recommended method for extracting a single file from a stash without affecting the stash itself.

Step-by-Step Process:

1. First, identify which stash contains the file you need:

git stash list

2. Extract the specific file from the stash:

git checkout stash@{<n>} -- <path/to/your/file>

Example:

# If you want to extract index.js from the most recent stash (stash@{0})
git checkout stash@{0} -- src/components/index.js

# If you want to extract config.json from the second stash (stash@{1})
git checkout stash@{1} -- config.json

Key Points:

• The -- separator is crucial to prevent Git from interpreting the filename as a branch name
• This method only extracts the file from the stash and doesn’t modify the stash
• The extracted file will be in the working directory but won’t be staged

Advantages:

• Simple and straightforward
• Doesn’t modify the stash
• Works for both staged and unstaged changes in the stash

Limitations:

• Only works for files that were part of the original stash
• Doesn’t show you what changes you’re extracting

Method 2: Creating and Applying a Patch File

This method involves creating a patch file from the stash and then applying it selectively.

Step-by-Step Process:

1. Generate a patch file from the stash:

git stash show -p stash@{<n>} > my-stash-patch.patch

2. Review the patch file (optional but recommended):

cat my-stash-patch.patch

3. Apply the patch to the specific file or directory:

# Apply to the entire working directory
git apply my-stash-patch.patch

# Apply to a specific directory
git apply my-stash-patch.patch --directory <path/to/target/dir>

# Apply with 3-way merge for complex changes
git apply -3 my-stash-patch.patch

4. Clean up the patch file when done:

rm my-stash-patch.patch

Advanced Usage:
You can also use git stash show with specific options to control what goes into the patch:

# Only show unstaged changes
git stash show -p --cached stash@{<n>} > staged-changes.patch

# Only show staged changes  
git stash show -p stash@{<n>} > unstaged-changes.patch

Advantages:

• Gives you full control over what changes to apply
• Allows you to review changes before applying
• Can be used to apply changes to different branches or repositories

Limitations:

• More complex than the checkout method
• Requires creating and managing temporary files
• May require manual conflict resolution

Method 3: Using Git Apply with Stash Output

This is a variation of the patch method that pipes the stash output directly to git apply.

One-Liner Solution:

git stash show -p stash@{<n>} | git apply

With Specific Target Directory:

git stash show -p stash@{<n>} | git apply --directory <path/to/target/dir>

Dry Run First (Recommended):

# Check what changes would be applied
git stash show -p stash@{<n>} | git apply --stat

# Apply with 3-way merge support
git stash show -p stash@{<n>} | git apply -3

Advantages:

• No temporary files needed
• Quick and efficient for single-use scenarios
• Easy to combine with other git commands

Limitations:

• Less transparent than the patch file method
• Harder to debug if something goes wrong
• Doesn’t provide as much control over application

Method 4: Pop and Reset (Temporary Approach)

This method temporarily pops the stash, extracts the file, and then restores the stash. Use this with caution as it’s more complex and error-prone.

Step-by-Step Process:

1. Pop the stash temporarily:

git stash pop

2. Extract the file you need (it’s now in your working directory):

git add <your-file>
git commit -m "Temporary commit for file extraction"

3. Reset to undo the stash application (keeping your file):

git reset HEAD~1

4. Restore the stash (this recreates it):

git stash push -m "Recreated stash"

Alternative Cleaner Version:

# Create a temporary branch
git stash pop
git stash branch temp-branch
git checkout <your-file>
git stash push -m "Recreated stash"
git checkout master
git branch -D temp-branch

Warning: This method is complex and can lead to data loss if not done carefully. Use only when absolutely necessary and make sure to backup your work first.

Advantages:

• Works in cases where other methods might fail
• Gives you full control over the stash contents

Limitations:

• High risk of data loss or corruption
• Complex and error-prone
• Leaves temporary commits or branches

Best Practices and Common Mistakes

Best Practices

1. Always use -- with checkout to prevent filename ambiguity
2. Verify stash contents before extraction:

git stash show stash@{<n>}

3. Use dry-run when possible:

git stash show -p stash@{<n>} | git apply --stat

4. Work on a clean working directory to avoid conflicts
5. Make a backup before attempting complex operations

Common Mistakes to Avoid

1. Forgetting the -- separator:

   bash

   # Wrong - Git might interpret filename as branch
   git checkout stash@{0} src/file.js
   
   # Correct
   git checkout stash@{0} -- src/file.js
   

2. Using git stash apply instead of checkout:

   bash

   # Wrong - This applies all changes from stash
   git stash apply stash@{<n>}
   
   # Correct for single file
   git checkout stash@{<n>} -- <file>
   

3. Assuming stashes contain only unstaged changes:

   • Stashes can contain both staged and unstaged changes
   • Use git stash show -p to see exactly what’s included

4. Not checking which stash you’re working with:

   • Always use git stash list to identify the correct stash index
   • Stash indices change when you add/remove stashes

Alternative Solutions

Using Git Reflog for Recovery

If you accidentally modify or drop a stash, you can potentially recover it using git reflog:

git reflog stash

Interactive Stash Management

For more complex scenarios, consider using interactive tools like tig or gitk to manage stashes visually:

# Use tig to browse stashes interactively
tig stash

# Use gitk to visualize stash contents
gitk --all

Scripting for Batch Operations

If you frequently need to extract multiple files from stashes, consider creating a script:

#!/bin/bash
# extract_from_stash.sh
if [ $# -ne 2 ]; then
    echo "Usage: $0 <stash_index> <file_path>"
    exit 1
fi

git checkout "stash@{$1}" -- "$2"
echo "Extracted $2 from stash@{$1}"

Advanced: Using Git Worktree

For complex workflows, consider using git worktree:

# Create a temporary worktree for stash extraction
git worktree add temp-stash-branch stash@{<n>}
# Copy files from temp-stash-branch
# Remove worktree when done
git worktree remove temp-stash-branch

Conclusion

Extracting a single file from a git stash without popping the entire stash is a common requirement in Git workflows. The most reliable and recommended method is using git checkout stash@{<n>} -- <file>, which extracts the file while preserving the stash intact. For more complex scenarios, patch-based approaches provide greater flexibility and control. Always verify stash contents before extraction, use proper syntax with the -- separator, and work with a clean working directory to avoid conflicts. While there are alternative approaches like temporary stashing or worktrees, the checkout method remains the simplest and safest for most use cases.

Sources

1. Official Git Documentation - Stash
2. Pro Git Book - Stashing
3. GitHub Git Documentation - Working with Stashes
4. Git Stash Best Practices - Atlassian