How to Git Stash Your Changes with Associated Name and Find it Afterwards

Developers often have to multitask. You might be working on a new feature and there might be a request to fix a bug. Or you might be the lead developer on multiple projects.

When you are switching between tasks, sometimes you don’t want to commit unfinished work. In these cases, the git stash command can be a great help. It allows you to stack your changes and later come back to the unfinished work without adding unnecessary commits to your git repositories.

A Workflow for Git Stash

Let’s initialize a git master branch and commit a file ReadMe.txt.

Now let’s add another file called a.txt to the master branch.

If you check the history, you’ll see:

Now let’s create a feature1 branch and add a b.txt file:

Open your b.txt file in an editor and put in the line:

And save the file. If you check your git status, you see the following:

Suppose, at this stage, you get a request to update the a.txt file on the master branch. But you are not done with the b.txt file. If you try to check out the master branch, you get the following error:

But you don’t want to commit the unfinished work in b.txt. You can use the git stash in this situation:

If you check b.txt, it should be empty:

If you check the stash, you’ll see:

If you try to check out the master branch, you should be able to do it now:

Suppose you make the changes necessary on the master and then go back to feature1 branch:

Your b.txt is still empty:

But if you get the changes from the stash using the following command:

The stash apply command took the stashed changes and applied it to b.txt file
You can complete your work in b.txt my modifying the line

 
To

Now go ahead and commit your changes:

Applying a stash doesn’t automatically clean it from the stash. You have to clean it up manually:

Why Git Stash with Name?

The git stash is a stack. So you can keep piling your changes.

Suppose you add “X” to b.txt, stash it, add a “Y” to b.txt, stash it and add a “Z” to b.txt and stash it. If you check the stash history, you’ll see something like this:

You have no way of knowing which stash has which change. When you are stashing, you can use the save option to put in comments. You can use the comments to attach a name to your stash and make them recognizable:

For adding “X”, “Y” and “Z” modification, you can get the following in your stash using the save option for each stash:

Now you have a name for each change you stashed. Unfortunately, you can’t use the name to retrieve the stash. You’ll have to use the stash number. Suppose you want to get your “Y” change. You see that stash@{1} is Y. So you can apply that change to your current branch:

And your b.txt should have the changes from stash@{1}.

You can use the same method to drop a stash. Suppose, you realize you don’t need the X stash any longer. You can just use the following command to delete that stash:

And the stash should be gone:

Remember that if you use the apply and drop options without any parameters, it will use the top of the stack (stash@{0}).

Conclusion

The git stash command is a powerful way to manage your workspace. Mastering this command will help you work more efficiently.

Further Study:

• https://git-scm.com/book/en/v1/Git-Tools-Stashing

References:

Stack Overflow: how-to-name-and-retrieve-a-stash-by-name-in-git