Just Learn Code

Unlocking the Power of Git: Stashing and Shelving Changes

Unlocking the Magic of Git Shelve and Git Stash

Git is an essential tool for anyone working on collaborative projects. It allows multiple developers to work seamlessly on the same codebase without disrupting each other’s work.

However, changes made by one developer can potentially cause conflicts with another developer’s changes. In such cases, it’s crucial to have tools that can safely store uncommitted changes and prevent code loss.

This is where Git Shelve and Git Stash come in handy.

Git Shelve – Shelving Uncommitted Changes

Git Shelve is a powerful command in Git that allows you to store unfinished work temporarily. Often, developers may want to take a break from their work midway through a change.

The problem is that uncommitted changes can be lost if they switch branches or pull from the remote repository. Git Shelve solves this problem by creating a temporary storage area where uncommitted changes can be safely stored.

To shelve uncommitted changes, you simply run the command, ‘git shelve.’ Git creates a new branch with the shelved changes, and the working directory reverts to the last commit. This way, developers don’t have to worry about losing uncommitted work while working on something else.

Applying Shelved Changes with Git Shelve

To restore the shelved changes, developers need to use the ‘git unshelve’ command. After executing this command, Git looks for the most recently shelved set of changes.

If there are conflicting changes, Git tries to merge them automatically. However, if there are still conflicts, developers need to manually resolve them.

One of the most significant benefits of Git Shelve is that it allows developers to switch between different branches without losing uncommitted changes. It provides an easy way to preserve unfinished work in a safe and temporary space.

Git Stash – Record of Changes in The Working Directory

Another useful Git command for storing uncommitted changes is ‘Git Stash.’ Git Stash creates a record of the current difference between the current working directory and the last commit. The record is stored in a hidden file, and the working directory reverts to the last commit.

Stashing changes is beneficial when you need to make changes outside of the current branch without affecting the branch’s integrity. Unlike Git Shelve, Git Stash does not create branches.

Instead, it creates a saved state of the currently checked-out branch.

Applying Stashed Changes with Git Stash

To apply the stashed changes, you need to use the ‘git apply’ command. This command applies the most recent stash if no arguments are passed.

Git also allows developers to apply the stashed changes to a separate branch to avoid conflicts. It’s good practice to name each stash when using git stash.

Giving each stash a descriptive name increases the clarity and readability of the command history.

Advantages of Git Stash

One of the significant advantages of Git Stash is that you can stash changes even if the current state of the working directory is dirty, i.e., has uncommitted changes. Git automatically saves both the uncommitted changes and the stashed changes.

Another advantage of Git Stash is that it allows you to move between branches quickly. You can stash changes in the current branch, switch to a new branch, and apply the stashed changes.

This reduces the risk of code loss and potential conflicts when working on multiple branches.


Git is a robust version control system that enables efficient collaboration in software development teams. Git Shelve and Git Stash are two commands that help store uncommitted changes and preserve them from being lost.

With Git Shelve, developers can create a temporary storage space and switch between branches without losing uncommitted changes. Git Stash, on the other hand, creates a record of changes in the working directory, making it easy to move between branches quickly.

In conclusion, working with Git Shelve and Git Stash can make your coding work smoother and more manageable. Try them out yourself, and you’ll soon discover how they can benefit your coding projects.

Git Shelve versus Git Stash: Which is Better for Your Project? Working with Git is essential for developers who want to collaborate smoothly on the same codebase.

However, managing uncommitted changes can be challenging, especially when working on different tasks. Two of the most popular Git commands for managing uncommitted changes are Git Shelve and Git Stash.

While both tools offer similar benefits, they differ in their methods of use and application. This article will provide a detailed comparison between Git Shelve and Git Stash and guide you through the workflow for shelving changes.

Similarities Between Git Shelve and Git Stash

Both Git Shelve and Git Stash allow developers to switch between tasks without losing uncommitted changes. For example, if you’re working on a particular task, and something more critical emerges, you could switch tasks and work on it without losing your uncommitted changes.

This is particularly convenient when using an integrated development environment like IntelliJ IDEA, which allows developers to switch between tasks with ease.

Differences Between Git Shelve and Git Stash

One significant difference between Git Shelve and Git Stash is the way they generate and apply patches. With Git Shelve, developers generate patches that capture the changes made to all files.

In contrast, with Git Stash, developers can choose which files to stash. This makes Git Stash ideal for developers who want to store changes that are specific to one file or some files.

Another difference is that Git Stash stashes all the changes, including the untracked files, while Git Shelve only stashes changes made to tracked files. This means that Git Stash may take up more space than Git Shelve.

Workflow for Shelving Changes

To properly utilize Git Shelve and Git Stash, you need to understand their workflows. Below is a detailed workflow for shelving changes using both tools.

Stashing Separate Files or All Changes

To commit changes using Git Shelve, use the git shelve command followed by the commit message. This will create a new branch with the shelved changes.

If you want to name and save the shelf, use git shelve –branch to name the branch explicitly. With Git Stash, you can stash separate files or all changes.

To stash specific files in the current working directory, use the git stash push command followed by the filename. To stash all changes in the working directory, use the git stash command without any arguments.

Naming and Saving the Shelf

When using Git Shelve, it’s crucial to name and save the shelf properly. You can do this by passing the –branch option followed by the name of the branch.

You can also use the -m option to add a commit message. With Git Stash, the stash is automatically saved with a default name, but you can name the stash by using the -m option followed by the name of the stash.

Unshelving Changes

Unshelving changes with Git Shelve is as simple as running the git unshelve command. This command restores all the changes saved in the shelf and automatically merges them with your current branch.

With Git Stash, you can unstash changes using the git stash apply command. This will restore the most recent stash, but if you want to unstash a particular stash, pass the stash ID as an argument.



Using Git Shelve and Git Stash can help developers switch between tasks without losing uncommitted changes. Both tools offer similar benefits, but their methods of use and application differ.

Understanding their workflows is crucial to properly utilizing these commands effectively. With these tools, developers can work on multiple tasks with ease and avoid potential conflicts in collaborative project environments.

Mastering the Workflow for Stashing Changes with Git

Stashing changes with Git is an incredibly useful tool for developers when working on multiple tasks simultaneously. With Git’s stash command, developers can store their uncommitted changes safely and cleanly switch to another task without losing their work.

Additionally, Git’s stash command allows developers to handle complex merge conflicts more efficiently. This article will guide you step-by-step through the workflow for stashing changes with Git and applying a stash when necessary.

Stashing Changes with IntelliJ IDEA

IntelliJ IDEA has an integrated Git interface that makes it easier to manage your changes. Here’s how to stash changes in IntelliJ IDEA:

Step 1: Navigate to the Git Panel

To stash your changes, go to the Git panel.

You can access the panel from the bottom toolbar or through the main menu. Step 2: Stash Your Changes

Once you have accessed the Git panel, click on the “Uncommitted Changes” tab.

Then, click on the “Stash Changes” button. This will stash your changes and remove them from the working directory, leaving behind a clean slate to start a new task.

Step 3: Verify The Directory

It’s crucial to stash your changes in the correct directory. Before stashing, verify that you’re stashing in the correct directory.

If you’re not, save your changes first and navigate to the correct directory before stashing. Step 4: Add a Message

After clicking the “Stash Changes” button, a pop-up window will appear.

Make sure to fill in the message field with a brief and descriptive name for the stash. This will help you know what changes the stash contains when applying it later.

Applying a Stash

Now that you’ve stashed your changes, how do you apply them later? Here’s a step-by-step guide:

Step 1: Analyzing the Stash

The first step to applying a stash is to determine the scope of the changes in the stash.

If you stashed your changes with a message, use this message to determine what changes are included in the stash. Step 2: Applying the Stash

To apply the stash, navigate to the Git panel, click the “Stash” tab, and select the appropriate stash from the list.

You can choose to apply the stash or to apply it and delete it from the stash list. Step 3: Handling Conflicts

In some cases, conflicts may arise when you try to apply your stash, especially if you have applied several stashes in between.

To handle conflicts, use the Git merge tool. The merge tool highlights the differences between files and allows you to pick and choose which changes to keep.

Once you’ve resolved all the conflicts, commit and push the changes.


Using Git’s stash command is an excellent way for developers to switch between tasks with ease and handle merge conflicts more efficiently. Stashing changes with Git is simple and straightforward, and applying a stash is just as easy as long as you know how to navigate the Git interface.

By mastering the Git stash workflow, developers can increase their productivity and achieve more in less time. In conclusion, stashing and shelving changes with Git are important tools for developers working on complex projects.

Git Stash and Git Shelve both offer unique ways to store uncommitted changes, allowing developers to switch tasks without losing their work. While they share some similarities, they differ in feature and use-case.

By mastering the workflow of stashing and shelving changes, developers can work more efficiently and reduce the risk of conflicts and code loss. Remember to check your directory and comments, properly name the stash, and analyze the stash before applying it.

With mastery comes improved productivity and code management.

Popular Posts