Writing code can be similar to writing tutorials. In both cases, you’ll typically need to create and work on multiple drafts before reaching the final version.
In an ideal setting, you would write code for a feature, add that code to the staging area, and then commit it before going to the next part. This helps keep your commit history clean. (Don't worry if you don't have a clean history. Many of us don’t.)
But now, imagine a scenario where you have multiple features to build. You've committed the first. You've started the third, but then you found out you needed to build the second one first, because the third depends on it. It might seem like you have to go back in time and build out that second feature without mixing in the code changes for the third, and without deleting the code changes for the third.
So how do you do that?
In this article, you’re going to learn about Git stash, what it is, and the basic commands you need to be able to use it.
What We’ll Cover:
To understand and get the most out of this tutorial, you’ll need to have a basic understanding of Git.
What is Git Stash?
Git stash provides storage (in the form of a stack) where you can store changes to your code. It lets you keep these changes separate from the current working directory until you're ready to apply them.
git stash is a relatively simple command, and has a few variations like:
git stash pushgit stash popgit stash applygit stash dropgit stash cleargit stash showgit stash list
How to Use Git Stash
Pushing Code Changes to the Stash
To push uncommitted changes from the working directory to the stash, you can use git stash push. When you do that, the changes disappear from the working directory and are saved in the stash. The working directory is then set back to the last commit (which, in the example below, is the Feature one).
git stash push
You can also write the git stash push command as just git stash – it means the same thing and performs the same way. You can also add a message to it with the -m or --message flag:
git stash push -m "Feature two I was working on"
You can use the -u flag or --include-untracked to include untracked changes in the stash. This way, the changes not yet tracked by Git can be included in the stash.
git stash push -u
git stash push --include-untracked
On the other hand, you can decide to push only staged changes to the stash with the -s or --staged flag:
git stash push -s
You can also suppress feedback messages with the -q or --quiet flag:
git stash push -q
When you're done with your edits on the current working directory, you can commit and push without the older changes bleeding into it. They're safely stowed away in the stash.
Anytime you use the git stash command, you add a stash to the stash list. The stashes are identified by their index numbers.
Applying Changes from the Stash to the Working Directory
Let’s say you had a quick fix to do. You’re done committing that, and you want to continue with what you were working on. You can restore the changes from the stash to continue working on them.
You can do this by using the git stash apply command or the git stash pop command:
git stash apply
git stash apply applies the latest changes from the stash to the working directory, but doesn’t delete the code from the stash. You can select a particular entry to apply by index number:
git stash apply --index stash@{1}
# You'd need to use quotes "stash@{1}" if you're writing this in PowerShell
git stash pop, on the other hand, applies the latest changes from the stash, then deletes them from the stash. Basically, popping from a stack. You can select a particular stash entry to pop by index number.
git stash pop
git stash pop --index stash@{1}
# You'd need to use quotes "stash@{1}" if you're writing this in PowerShell
Listing the Items in the Stash List
You can use git stash list to list out the stashes in the stash list. It’s arranged by index number (like {0}, {1}, and so on). Any time you do a git stash push, it adds a stash to the stash list.
git stash list
stash@{0}: WIP on master: b2a2709 Feature one
stash@{1}: WIP on master: b2a2709 Feature one
Removing Items from the Stash
You can use git stash clear to clear the stash list. But if you just want to drop a particular entry from the stash list, you can use git stash drop and specify the entry you want to drop by the index number. This doesn’t apply its changes to the working directory.
git stash clear
git stash drop stash@{0}
# You'd need to use quotes "stash@{0}" if you're writing this in PowerShell
Creating a New Branch from Stash
You can also create a new branch from a stash using git stash branch. The syntax is git stash branch <branchname> [<stash>].
git stash branch premium-branch stash@{0}
# You'd need to use quotes "stash@{0}" if you're writing this in PowerShell
If you don’t add the stash index, it will just use the last stash.
git stash branch premium-branch
Showing the Changes in the Stash
You can use git stash show to show the changes you’ve made in your stashed changes.
C:\file-path\git_stash_example> git stash show
text.md | 4 +++-
1 file changed, 3 insertions(+), 1 deletion(-)
Conclusion
Git stash is one of those quiet tools that becomes indispensable once your workflow starts to get messy. It allows you to shelve unfinished ideas, switch context without panic, and keep your commits clean. With it, you can safely carry out urgent fixes, and juggle dependent features without muddling up your commit history.
If you enjoyed this article, share it with others. You can also reach me on LinkedIn or X.