Git Stash

What Git Stash Is For

Git stash lets you temporarily set aside local changes without committing them. It is useful when you are halfway through one task and suddenly need to switch branches to fix something urgent.

Instead of creating a messy “work in progress” commit, you can stash the changes, do the urgent task, and then restore your original work later.

Tip: Stash is great for short-term interruptions. For longer work, a real branch and commit are usually safer.

Creating a Basic Stash

Suppose you modified app.js and README.md but are not ready to commit.

Check the status:

git status

Now stash the tracked changes:

git stash

Git saves the current state and reverts your working directory to match the last commit.

You can confirm with:

git status

The working tree should now be clean.

Listing Stashes

To see saved stashes:

git stash list

Example output:

stash@{0}: WIP on feature/login: a1b2c3d Add login page
stash@{1}: WIP on main: d4e5f6g Update README

Each stash has an identifier like stash@{0}.

Restoring a Stash with apply

Use git stash apply when you want to restore a stash but keep it in the stash list.

git stash apply stash@{0}

This is useful if you want to test the restored changes before deciding whether to remove the stash entry.

If you omit the name, Git applies the latest stash:

git stash apply

Restoring and Removing with pop

Use git stash pop when you want to restore a stash and remove it from the stash list in one step.

git stash pop

This is the most common restore command.

apply vs pop

• apply: restore but keep the stash saved
• pop: restore and delete the stash entry if successful

Naming a Stash

Default stash messages are not always easy to remember. You can create a named stash:

git stash push -m "half-finished navbar styling"

List it later:

git stash list

Named stashes are much easier to identify when you have several saved states.

Stashing Untracked Files

By default, git stash saves changes to tracked files only. If you also want to include untracked files, use -u.

git stash push -u -m "save new config files too"

This is helpful when you created new files but are not ready to commit them yet.

Note: Untracked files are files Git sees but is not yet tracking. Ignored files are a separate category and are not included unless you use additional options.

Dropping and Clearing Stashes

To delete one stash entry:

git stash drop stash@{0}

To remove all stash entries:

git stash clear

Be careful with clear because it removes everything from the stash list.

A Real Workflow Example

Imagine you are on feature/docs editing tutorial content when a production issue appears.

git status
git stash push -m "draft updates for Git basics"
git switch main
git switch -c hotfix/header-bug
# fix the issue
git add .
git commit -m "Fix broken header in production"
git switch feature/docs
git stash pop

This lets you pause one task, fix another, and return without creating a confusing temporary commit.

Handling Stash Conflicts

Applying a stash can sometimes create conflicts, especially if the branch changed since the stash was created.

If that happens:

1. run git status
2. resolve the conflicts manually
3. stage the resolved files with git add
4. continue working or commit the result

A stash is not magic. It still depends on how different the files became over time.

When Not to Use Stash

Stash is not ideal for everything.

Avoid relying on stash when:

• you need a durable backup of important work
• the work should be reviewed by others
• you are pausing for a long period
• you are working across multiple machines

In those cases, a normal branch and commit are usually better.

What You Should Remember

Git stash is a temporary shelf for unfinished work. Use stash to save changes quickly, list to inspect saved entries, apply or pop to restore them, and drop or clear to clean them up. Use -u for untracked files and -m for a helpful message.

For quick interruptions, stash is excellent. For meaningful milestones, commit to a branch instead.

Test Your Understanding

Exercise 1: Pausing work quickly

Scenario: You are halfway through editing app.js and README.md, and an urgent bug forces you to switch tasks immediately.

Question: Which Git feature from this lesson is designed for that short-term interruption without making a work-in-progress commit?

<MCQExercise exercise={{ id: 'git-stash-q1', title: 'Exercise 1: Pausing work quickly', description: 'Choose the Git feature intended for temporarily shelving unfinished local changes.', options: [ { id: 'a', text: 'git tag' }, { id: 'b', text: 'git stash' }, { id: 'c', text: 'git revert' }, { id: 'd', text: 'git cherry-pick' }, ], correctId: 'b', explanation: 'The tutorial positioned stash as a short-term shelf for unfinished local changes. It is a clean way to pause one task, switch context, and later restore the saved work.', wrongExplanations: { a: 'Tags mark commits in history, not temporary uncommitted working changes.', c: 'Revert creates a new commit that undoes an earlier commit. It does not shelve in-progress edits.', d: 'Cherry-pick copies an existing commit to another branch, which is unrelated to pausing uncommitted work.', }, }} />

Exercise 2: Saving untracked files too

Scenario: Your unfinished work includes brand-new config files that are still untracked, and you want a descriptive stash entry.

Question: Which command best matches the tutorial?

<MCQExercise exercise={{ id: 'git-stash-q2', title: 'Exercise 2: Saving untracked files too', description: 'Choose the stash command that includes untracked files and adds a helpful message.', options: [ { id: 'a', text: 'git stash clear -m "save config"' }, { id: 'b', text: 'git stash apply -u "save config"' }, { id: 'c', text: 'git stash drop -u -m "save config"' }, { id: 'd', text: 'git stash push -u -m "save config"' }, ], correctId: 'd', explanation: 'The lesson showed git stash push -u -m "..." for exactly this case. -u includes untracked files, and -m adds a meaningful label that is easier to recognize later in git stash list.', wrongExplanations: { a: 'clear removes stashes; it does not create a new one.', b: 'apply restores an existing stash and does not create a named stash entry.', c: 'drop deletes an existing stash entry rather than saving your current work.', }, }} />

Exercise 3: Keeping the stash after restore

Scenario: You want to restore a stash to test something, but you do not want the stash entry removed yet.

Question: Which command should you prefer?

<MCQExercise exercise={{ id: 'git-stash-q3', title: 'Exercise 3: Keeping the stash after restore', description: 'Pick the restore command that leaves the stash entry in the list.', options: [ { id: 'a', text: 'git stash apply' }, { id: 'b', text: 'git stash pop' }, { id: 'c', text: 'git stash clear' }, { id: 'd', text: 'git stash branch' }, ], correctId: 'a', explanation: 'The tutorial contrasted apply with pop: apply restores the changes but keeps the stash entry saved. That is useful when you want to verify or reuse the stash before deleting it.', wrongExplanations: { b: 'pop usually restores and removes the stash entry, which is the opposite of the goal here.', c: 'clear deletes all stash entries and would destroy the saved work.', d: 'The lesson focused on apply versus pop for restore behavior, and branch creation is not the simplest answer to this question.', }, }} />