git stash - Store your uncommitted changes aside to work on it later

Subscribe to my newsletter and never miss my upcoming articles

Introduction

In this post, we'll be looking at the git stash command and its usage. We come across situations in our development work where we are in the middle of a task with quite a good amount of code changes and have to switch to some other task that has come on priority. Now, if the changes are somewhat complete then we can commit it and start with the other task but what if those changes are unfinished and far away from a meaningful commit, in that case instead of committing it we can make use of

git stash

git stash stores the uncommitted changes that we've made on our current branch away to be used at a later point in time and we are left with the code that was present before those changes. This allows us to work on our other task and get back to the stashed one later.

git stash

Suppose we have a demo project and we've modified some files in it

screenshot 1.png

As we can see from the above screenshot that we have modified two files and now we'll use git stash

git stash.png

After performing git stash, the changes get stashed and when we use git status, it shows that there is nothing to commit. Now, we can work on any other changes, switch branches and perform different operations and once we are done, we can re-apply the stash and continue working on it.

Re-applying the stashed changes

We can use the following command to re-apply the stashed changes

git stash pop

git stash pop.png

We see that the above command pops out our stashed changes and applies them to the current branch. After the changes are applied, it gets removed from the stash.

If we don't want our changes to be removed from the stash after applying it on the branch, we can use the following command

git stash apply

This command can be used to apply the same changes on multiple branches.

Multiple stashes

We are not limited to a single stash and can use the git stash command multiple times to create as many stash as required. We can then use the following command to view our stashes.

git stash list

Suppose, we've created few stashes by running the git stash command multiple times

git stash list.png

We see that this command list out all the stashes that we've created and the stashes are identified as

stash@{n}: WIP(work in progress) on (branch on which stash is created): (commit from which the stash is created)

Identifying which stash contains what change becomes difficult as the message does not provide any context related to the change that it holds. Therefore, instead of using only git stash we can use the following command that adds a description to the stash

git stash save "description to give you an idea about your change"

git stash save.png

git stash pop and git stash apply re-applies the most recently created stash which is stash@{0}. If we want to re-apply the changes from a different stash, we should pass its identifier as the last argument to the respective commands.

git stash pop stash@{3}
git stash apply stash@{3}

Stash untracked and ignored files

By default, git stash stores the staged and unstaged changes only. It will not store the new files added to the directory that has not been staged yet and also the files that have been ignored.

If we also want to stash the new files, we can use the following command

git stash save "description" -u
OR
git stash save "description" --include-untracked

Using the following command will stash all the files including the ignored ones

git stash save "description" -a
OR
git stash save "description" --all

View the changes recorded in a stash

We can use the following command to view the changes recorded in a particular stash as a diff between the stashed contents and the commit back when the stash was first created.

git stash show -p stash@{n}

Stash specific files

We can make use of the --patch flag while running the git stash command that instructs Git not to stash everything that is modified instead it will iterate through all the changes and ask whether we want to stash it or not

git stash save "description" -p
OR
git stash save "description" --patch

Create a branch from the stash

Suppose we stashed some changes from a branch and continue to work on that particular branch and later try to re-apply those stashed changes, it might happen that the stashed changes try to modify a file which has already been modified and it results in a merge conflict. In that case we'll have to resolve the conflict or what we can do is use the following command that creates a new branch and checks out the commit we were on when the stash was created and reapply the stashed changes and removes the stash if it gets applied successfully.

git stash branch branch_name stash@{n}

git stash branch.png

Cleaning the stash

So far we've seen how to create a stash and re-apply those changes back, now we'll be looking at the commands that will allow us to delete the stash. If we want to delete a particular stash, we can use the following command to delete it

git stash drop stash@{n}

git stash drop.png

In case we want to delete all the stashes, it can be done using

git stash clear

Conclusion

In this post, we learned about the git stash command that lets us store our uncommitted changes that are not ready enough to be committed. We learned how to stash our work and also re-apply the changes back.

By default, the stash command only stores the staged and unstaged changes so we learned how to stash the untracked and ignored files as well. We learned the command to view the changes stored in a stash and also stash specific files. Lastly, we created a branch from the stash and also deleted the created stashes.


Thanks for taking the time to read this post. I hope this post helped you in learning something and if you enjoyed it, please share.

It would be great to connect with you on Twitter. Please do share your valuable feedback and suggestions👋

Phillip Ninan's photo

Very detailed read on stashes! I learned something new. I typically only used stash and pop.

Raunaq Chawhan's photo

Thank you, means a lot!😊

Maxi Contieri's photo

Nice article!

It is very useful to stash in git