Command git stash: The Ultimate Guide to Git Stashing

As developers, we often find ourselves in situations where we’re working on something but need to temporarily save our progress to jump to another task. This is where Git’s stash feature comes in handy. The git stash command allows you to save your uncommitted changes and retrieve them later without cluttering your commit history. In this article, we’ll dive deep into the git stash command, explaining its functionality, providing examples, and showing you how it can make your workflow much more efficient.

What is the Command git stash?

In Git, the git stash command is used to temporarily save changes that you’re not yet ready to commit. It “stashes” your modifications away, allowing you to work on something else and come back to your previous work later. The main advantage of using git stash is that it enables you to switch contexts without committing unfinished work or losing your changes.

For example, you might be working on a new feature, but an urgent bug fix needs to be addressed in another branch. Instead of committing incomplete code or discarding your changes, you can use git stash to save your progress temporarily. Once you’re done with the bug fix, you can switch back to your previous task and apply the stashed changes.

How to Use the Command git stash

Let’s look at the basic usage of the git stash command, as well as some advanced options that can help improve your workflow.

1. Stashing Changes

The basic syntax for stashing changes is simple:

git stash

This command will save your uncommitted changes (both staged and unstaged) and revert your working directory to the last commit. You can then safely switch branches or perform other Git operations without worrying about losing your changes.

After running git stash, Git creates a new entry in the stash stack and displays a message like this:

Saved working directory and index state WIP on master: abc1234 Commit message

“WIP” stands for "Work In Progress," and the “abc1234” is a shorthand for your commit hash.

2. Viewing Stashed Changes

If you’ve stashed multiple sets of changes, you can list them by running:

git stash list

This will display a list of all the stashes you’ve made, with the most recent stash at the top:

stash@{0}: WIP on master: abc1234 Commit message
stash@{1}: WIP on feature-branch: def5678 Another commit message

The “stash@{0}” is the most recent stash, “stash@{1}” is the second most recent, and so on. This makes it easy to keep track of your stashes, especially if you work on multiple tasks at once.

3. Applying Stashed Changes

When you’re ready to get back to your work, you can apply the stashed changes using:

git stash apply

By default, this will apply the most recent stash (stash@{0}) to your working directory. If you want to apply a specific stash, you can reference it by its name, like this:

git stash apply stash@{1}

After applying a stash, your working directory will be updated with the changes from the stash, but the stash itself will still remain in the stash list. This is useful if you want to apply the same stash to multiple branches or locations.

4. Removing Stashes

Once you’ve applied a stash and no longer need it, you can remove it from the stash list using:

git stash drop stash@{0}

This will remove the specified stash from the list. If you want to remove all stashes, you can run:

git stash clear

This will completely clear the stash list, so use it carefully!

5. Stashing Only Staged or Unstaged Changes

Sometimes, you may only want to stash either staged or unstaged changes, not both. Git allows you to specify this behavior with the following options:

• Stash only staged changes:

  git stash push -k

• Stash only unstaged changes:

  git stash push -p

The -k option will stash only the staged changes, and -p will stash only the unstaged changes. This is helpful when you need to save just part of your work but don’t want to stash everything.

6. Stashing Untracked Files

By default, git stash does not stash untracked files (files that are not yet added to the Git index). However, if you want to stash these untracked files as well, you can use the -u (or --include-untracked) option:

git stash -u

If you want to stash both untracked and ignored files, you can use the -a option:

git stash -a

These options are useful when you have new files in your working directory that you’re not yet ready to commit but want to stash them temporarily.

Examples of Using git stash

1. Switching Tasks Without Losing Progress

Imagine you're working on a feature in a Git branch, but an urgent bug comes up that needs to be fixed in another branch. Instead of committing incomplete work, you can stash your changes, switch to the bug-fix branch, and work on it:

git stash
git checkout bug-fix
# Fix the bug, commit changes
git checkout feature-branch
git stash apply

Now, you’re back to your feature branch, and all your work is intact. You can continue where you left off!

2. Experimenting with Code Changes

If you’re experimenting with some new code and want to test it without committing the changes, you can stash them. For instance:

git stash
# Experiment with some code changes
git stash apply

This allows you to experiment freely while keeping your main branch clean and unaffected by your temporary changes.

Best Practices for Using git stash

While git stash is an incredibly powerful tool, it’s important to use it wisely:

• Don’t Overuse It: Stashing should be used for temporary storage. If you find yourself stashing changes often, it may be a sign that you need to commit more frequently.
• Use Descriptive Commit Messages: When working with stashes, make sure to leave detailed commit messages so you know exactly what you stashed and why.
• Apply and Clear Stashes Promptly: Once you’ve applied a stash and no longer need it, clear it from the stash list to avoid clutter.

Conclusion

The git stash command is an invaluable tool for developers working with Git, allowing them to temporarily save changes and switch tasks without losing progress. Whether you need to experiment with code, fix bugs, or simply take a break from your current work, stashing offers a way to keep your workflow clean and efficient. By understanding the ins and outs of git stash and applying it in the right situations, you can enhance your development experience and make your Git workflow smoother than ever!