Git Stash Deep Dive

# CHAPTER 7

Git Stash Deep Dive #

1. Introduction #

2. Learning Objectives #

• Define the operational concept of the Git Stash.

• Execute basic stash creation, inspection, and retrieval (push, list, pop).

• Apply stashed changes without deleting them from the stash stack.

• Stash specific files or partial hunks of code interactively.

• Convert a stash directly into a new feature branch.

3. Beginner-to-Advanced Explanations #

The Advanced Stash: The Stash is an invisible clipboard (technically, a hidden stack of anonymous commits). When you type git stash, Git sweeps all your uncommitted, modified files off your desk and shoves them into a drawer. Your working directory instantly reverts to a completely clean state. You switch to main, fix the bug, and commit. You switch back to your feature branch. You open the drawer (git stash pop), and Git perfectly places all your messy, half-written code right back on your desk exactly where you left it.

4. Git Command Walkthroughs #

# 1. Sweep messy code into the drawer
git stash

# (Optional) Give the stash a descriptive name so you remember what it is!
git stash push -m "Half-finished algorithm"

# 2. Look inside the drawer (List all stashes)
git stash list
# Output: stash@{0}: On main: Half-finished algorithm
# Output: stash@{1}: WIP on feature: broken CSS

# 3. Take the code out of the drawer and put it back on the desk
# (This applies the code AND deletes it from the drawer)
git stash pop

# 4. Take the code out, but KEEP a backup copy inside the drawer
git stash apply stash@{1}

# 5. Throw the code in the drawer away permanently
git stash drop stash@{0}

5. Partial Stashing #

# Only stash this specific file, leave everything else on the desk
git stash push -m "Hide just the config" config.json

6. Mini Project: Switch Projects Using Stash Workflow #

Step-by-Step Walkthrough:

1. 1. Create a repository: mkdir stash-demo && cd stash-demo && git init

1. 2. Create the production code: echo "Production App" > app.txt && git add . && git commit -m "V1"

1. 3. Start a feature: git checkout -b feature-new

1. 4. Write complex, messy code: echo "function brokenAlgorithm() { // TODO: fix this }" > algo.js

1. 5. The Emergency: The boss yells to fix a typo on main.

1. 6. Try to switch branches: git checkout main. (If algo.js was tracked, Git might warn you about bringing dirty changes).

1. 7. The Stash: Run git stash push -m "Save broken algo".

1. 8. Verify your directory is clean: ls. algo.js has vanished!

1. 9. Switch to main: git checkout main.

1. 10. Fix the bug: echo "Fixed App" > app.txt && git commit -am "Hotfix"

1. 11. Return to work: git checkout feature-new

1. 12. The Retrieval: Run git stash pop. algo.js magically reappears in your folder, exactly as you left it.

7. Branching from a Stash #

# This creates a new branch called 'experimental', switches to it, 
# and pops stash 0 onto it automatically!
git stash branch experimental stash@{0}

8. Best Practices #

• Do Not Use Stash for Long-Term Storage: The stash is a temporary drawer. It is not version control. If you have code sitting in a stash for 3 weeks, you are doing it wrong. That code should be committed to a formal feature branch. Stashes should live for hours, not days.

9. Common Mistakes #

• Forgetting Untracked Files: By default, git stash ONLY hides files that Git is currently tracking. If you create a brand new file new-script.js (which is untracked) and type git stash, the new file will NOT be stashed; it will remain sitting in your folder. To force Git to stash literally everything, use git stash -u (include untracked).

10. Exercises #

1. 1. Explain the operational difference between git stash pop and git stash apply.

1. 2. Why is the Stash conceptually described as a "stack" structure (LIFO - Last In, First Out)?

11. FAQs #

12. Summary #

13. Next Chapter Recommendation #