How to use Git stashes as a temporary storage

Let's say you're coding on your development branch. And you get a notice that there's a bug on the production branch.

You want to check for the bug, but you don't want to lose the work you've created on the development branch. You also don't want to commit what you've written because they're not done yet.

What do you do? You can't commit and you can't switch branches. If you switch branches, things that aren't committed will flow over to the branch you switched to.

What you want to do is save the changes somewhere temporary while you switch over to another branch. *A Git stash is that temporary storage. *

Using a Stash with Git Fork

To use a stash, you need to start with some uncommitted code. For this lesson, we're going to use the following piece of code as the uncommitted changes:

<!-- Some uncommitted code in index.html -->
<main>
  <p> A new paragraph</p>
</main>

To stash this code, you can click on the stash button.

Once you click on the stash button, Fork will ask you to leave a message. This message indicates what the stash is about.

Since stashes are temporary, you can use whatever name you want. We're going to call it "Temp storage".

Once you create a new stash, you'll find it in the Stashes section on the sidebar.

Note: You won't be able to see the changes in this stash, but that's not a problem because you won't have to. What you want to do is switch your branch, finish what you need to do and switch back.

In this case, we're going to check out to the master branch. When you do so, notice you don't see the uncommitted code we wrote above in both the master and develop branches.

Applying stashed changes

You can go back to the branch you were at, then right-click on your stash and select Apply stash.

Fork will ask you whether to delete the stash when you do so. I usually delete the stash because I don't want to keep more than one stash at one time.

Once you apply the stash, you'll be able to see the changes you made.

<!-- You'll see your uncommitted code again! -->
<main>
  <p> A new paragraph</p>
</main>

Wrapping up

Stashes are temporary storages where you can store you code. When you've stored your code, you can move to other branches to do something else.

When you're done, you can put your code back from the stash.

With Git Stash, you won't have to worry about losing any uncommitted changes!

---

Thanks for reading. This article was originally posted on my blog. Sign up for my newsletter if you want more articles to help you become a better frontend developer.

Comments

[Florimond Manca]

Interesting point on using git stash to save changes for later; the production bug fix use case is exactly what I use git stash for the most.

For those wondering about the command line process:

(feature/xyz) $ git status
On branch feature/xyz
Untracked files:
  (use "git add <file>..." to include in what will be committed)

        somefile.txt

nothing added to commit but untracked files present (use "git add" to track)
# Add changes to the index
(feature/xyz) $ git add -A
# Stash changes, possibly leave a message through the -m argument
(feature/xyz) $ git stash
Saved working directory and index state WIP on feature/xyz: 076cc04 some-previous-commit
HEAD is now at 076cc04 some-previous-commit
# We're now in a clean state, ready to go fix the bug on master
(feature/xyz) $ git checkout master
(master) $ ./do-and-commit-stuff.sh
# Now come back to your branch and put back your changes from the stash
(master) $ git checkout feature/xyz
(feature/xyz) $ git stash apply
On branch feature/xyz
Changes to be committed:
  (use "git reset HEAD <file>..." to unstage)

        new file:   somefile.txt  # <- previous changes are back! 🎉