Git Stash: A Complete Overview

Ever found yourself in the middle of coding when an urgent task forces you to switch gears? What happens to your uncommitted changes? This is where Git Stash comes in handy. Git Stash is a robust tool that enables developers to store their work temporarily. It ensures no progress is lost when they need to switch to other tasks. By stashing your changes, you can easily return to a clean working directory, ready to tackle any pressing issues without worrying about unfinished work.

In this blog, we’ll explore the ins and outs of Git Stash, guiding you through its functions, benefits, and practical applications. Whether you’re new to Version Control or looking to refine your workflow, understanding Git Stash is essential for seamless project management and coding efficiency.

Table of Contents

1) What is Git Stash?

2) Working of Git Stash

3) Which Folder Holds the History of the Git Stash?

4) How to Store Changes in Git Stash?

5) Difference Between Git Stash and Git Stage

6) Difference Between Git Stash and Git Reset

7) Difference Between Git Stash and Git Commit

8) Creating a Branch From Your Stash

9) Cleaning up Your Stash

10) Examples of Git Stash

11) Conclusion

What is Git Stash?

When working on a project, you might find yourself in the middle of a task when an urgent bug fix or a different feature requires immediate attention. You could commit to your changes, but what if they aren’t ready to be committed? This is where Git Stash comes into play. Git Stash allows you to temporarily save your unfinished changes and revert to a clean working directory. This way, you can quickly switch tasks without losing your progress.

Git Stash is like a safety net. It stores your changes in a stack-like structure, allowing you to apply or discard them later. This flexibility is essential when you’re managing multiple tasks and need to pause work on one without cluttering your commit history.

Working of Git Stash

Git Stash operates by temporarily shelving the changes in your working directory and staging area which haven’t been committed yet. When you run the Git Stash command, it takes your uncommitted changes, including new files and changes in tracked files, and saves them in a stack. Your working directory and staging area are then cleaned up as if you never made those changes. You can later apply the stashed changes using Git Stash apply or Git Stash pop.

Each time you stash your changes, Git creates a new entry in the stash stack. These entries are numbered, starting from zero, and you can list them using Git Stash list. The beauty of Git Stash lies in its ability to help you manage multiple stashes and decide when and how to reapply your changes.

Which Folder Holds the History of the Git Stash?

The history of your stashed changes is stored in a hidden directory within your Git Repository. Specifically, it resides in the .git/refs/stash file. This file maintains the references to all the stashes you’ve created. Git internally stores the stashed changes as commits, although they aren’t part of your branch history.

When you create a stash, Git generates a commit object with the changes you stashed. The .git/refs/stash file points to the latest stash, and this chain continues, with each stash referencing the one before it. This system ensures that you can retrieve, apply, or drop any stash as needed.

How to Store Changes in Git Stash?

Storing changes in Git Stash is straightforward. To stash your changes, simply use the command:

This command stashes the changes in your working directory and staging area. If you want to stash only changes in the working directory, excluding staged changes, use:

Adding a message can be helpful when you’re dealing with multiple stashes, as it allows you to identify them easily.

If you only want to stash changes from specific files, you can specify them:

To apply a stash, use:

Or, if you want to apply and remove the stash from the stack, use:

You can also specify a particular stash to apply by its index number:

Unlock your potential—join our App & Web Development Trainingsand build the future today!

Difference Between Git Stash and Git Stage

Git Stash and Git Stage serve different purposes in the Git workflow. The Git Stage is also known as the staging area. It is the phase where changes are prepared for the next commit. When you stage files using git add, they are moved to the staging area, awaiting a commit.

On the other hand, Git Stash is used to temporarily save changes that you are not ready to commit or stage. You can also rename a branch in Git while stashing changes. Stashing does not move changes to the staging area but saves them in a separate storage within Git. This allows you to clear your working directory without losing your work, enabling you to switch branches or work on something else.

In summary, Git Stage is about preparing changes for a commit, while Git Stash is about temporarily setting aside changes you’re not ready to commit.

Difference Between Git Stash and Git Reset

Git Stash and Git Reset both affect the state of your working directory, but they do so in very different ways.

Git Reset is used to undo changes by moving the current HEAD to a different commit. Depending on the options you use (--soft, --mixed, --hard), it can reset the staging area and/or the working directory to match the specified commit. This action is usually irreversible, especially with --hard, which deletes changes from both the staging area and working directory.

Git Stash, however, does not discard your changes permanently. Instead, it saves them in a separate stash stack, allowing you to restore them later. While Git Reset is about rolling back to a previous state, Git Stash is about temporarily saving and clearing changes without losing them.

Difference Between Git Stash and Git Commit

Git Commit is the cornerstone of Version Control. It permanently saves changes to the repository’s history, making them part of the project’s timeline. Once committed, changes are tracked and can be shared with others or rolled back if needed.

Git Stash, however, does not save changes to the project’s history. It temporarily stores them in a stash stack, allowing you to revisit them later. Stashing is useful when your changes are not ready for a commit, but you need to clear your working directory or switch branches. In essence, while Git Commit is a permanent record of your work, Git Stash is a temporary holding area for unfinished changes.

Creating a Branch From Your Stash

Sometimes, you may want to turn your stashed changes into a new branch. This can be especially useful if you realise that your stashed work deserves its own branch. In order to create a new branch from a stash, you can use the following command:

git stash branch

This command does two things: it creates a new branch based on the commit where you originally stashed your changes, and it applies the stash to this new branch. Your working directory will now contain the stashed changes, and you can continue working on them as part of the new branch.

Cleaning up Your Stash

Over time, you might accumulate several stashes that are no longer needed. Cleaning up your stash is essential to keep your repository tidy. You can view your stashes using:

git stash list

To drop a specific stash, use:

Or, if you want to clear all stashes, use:

Be cautious when clearing stashes, as this action is irreversible, and you’ll lose any changes stored in the stashes.

Become a full-stack pro—Join our MEAN Stack Web Development Trainingtoday!

Examples of Git Stash

Here are a few practical examples of using Git Stash:

a) Stashing Uncommitted Changes: If you’re in the middle of working on a feature and need to switch branches, you can stash your changes with Git Stash and switch branches without worrying about your unfinished work.

b) Applying a Stash: After resolving the urgent task, you can return to your previous work by applying the stash with Git Stash apply.

c) Creating a Branch from a Stash: If your stashed changes evolve into a larger task, you can then create a new branch using Git Stash branch feature-branch and continue working on it.

d) Dropping a Stash: Once you’re done with a stash, you can remove it from the stack using Git Stash drop stash@{0}.

Conclusion

Perforce vs Git presents different approaches to version control, and within Git, Git Stash is a powerful tool that offers flexibility when managing your work. It allows you to save changes temporarily, keep your working directory clean, and revisit your stashed work whenever necessary. Additionally, Git Rebase helps streamline commit history by integrating changes in a more structured manner, making collaboration more efficient. Understanding the nuances between Git Stash, Git Stage, Git Reset, and Git Commit can enhance your workflow and make you more efficient in managing your code. Additionally, knowing how to delete a branch in git when it is no longer needed helps maintain a tidy repository.

Start your journey with Git & GitHub today and elevate your coding skills. Join our Git & GitHub Fundamentals Course.