?? Mastering Git Stash: The Hidden Superpower for Devs! ???

In the fast-paced world of software development, the ability to smoothly transition between tasks and branches is a highly valued skill. Git’s “stashing” feature emerges as a saving grace in situations where you need to temporarily set aside your ongoing work. Stashing allows you to store your work-in-progress without committing it, thereby maintaining a clean working directory and safeguarding your modifications. This article will delve into the core concepts of Git stash, covering how to stash changes, apply stashed changes, and efficiently manage your stash stack.

Stash acts as a "clipboard" where you can store all your uncommitted changes,
leaving your working copy in a clean state. This allows you to restore these 
changes later, at any time, as needed.        

Table of Contents:

• ?? Exploring Git Stash: Gain insights into stash functionality.
• ?? Storing Changes with Stash: Preserve work-in-progress seamlessly.
• ?? Restoring Stashed Edits: Retrieve saved changes effortlessly.
• ??? Dropping your stash: Cleanly remove unwanted stashed items.
• ?? Clearing your Stash History: Maintain workspace cleanliness and organization.
• ?? Handling Stash Conflicts and Errors: Resolve issues efficiently for smooth collaboration and code integration.

Why Stashing?

?Git Stash simplifies work flexibility by providing an effortless way to manage your changes.

?It’s typically employed in the following scenarios:?

• Incorporating or modifying elements after the latest commit that deviate from the changes in your working directory.
• Discovering a new feature or bug that requires immediate attention.
• Implementing experimental code changes in the working directory without committing them.
• Merging a local or remote branch without causing conflicts with your working directory alterations.

Exploring Git Stash

Imagine you’re working hard on a project, fixing things and adding cool features. But then, someone urgently needs your help with something else. You don’t want to mess up what you’re working on by saving it in a messy way.

That’s when you can use something called git stash. It’s like putting your work in a secret hiding place for a while. Your computer goes back to how it was before you started working on anything new. But don’t worry, your work is safe and sound, just hidden away.

Storing Changes with Stash

To stash your work smoothly, you just type a simple command: git stash

Assume We are working in a file called index.html

index.html

C:\Users\xyz\demo2> git add .
C:\Users\xyz\demo2> git stash
Saved working directory and index state WIP on master: 3e79938 after stash        

Thus we have stashed our work safely. Now you can peacefully switch to the feature_branch, ready to tackle the urgent matter at hand, with your masterpiece safely stashed away for later.

Did you happen to miss adding a label to your stashes?

Well, think of git stash save as your artistic palette. If you're the descriptive type who likes to label your stashes, it's just like adding that extra touch to your work:

C:\Users\xyz\demo2> git stash save "added image and form"
Saved working directory and index state On master: added image and form        

To list down all stashes done till now C:\Users\xyz\demo2>git stash list
stash@{0}: On master: added image and form
stash@{1}: WIP on master: 3e79938 after stash        

Thus, it helps you store your work like an artist’s palette, enabling you to add labels for additional organization and clarity in your projects.

Restoring Stashed Edits

git Stash Apply, git Stash pop , git Stash drop, git stash clear

Git Stash Apply

C:\Users\xyz\demo2>echo >addaccount.html
C:\Users\xyz\demo2>git add .
C:\Users\xyz\demo2>git status
On branch master
Changes to be committed:
  (use "git restore --staged <file>..." to unstage)
        new file:   addaccount.html        

C:\Users\xyz\demo2> git stash
Saved working directory and index state WIP on master: 3e79938 after stash
C:\Users\xyz\demo2> git status 
On branch master
nothing to commit, working tree cleanC:\Users\xyz\demo2>git stash apply
On branch master
Changes to be committed:
  (use "git restore --staged <file>..." to unstage)
        new file:   addaccount.html        

The git stash apply command by default applies the changes from the most recent stash in the stash stack. It brings in the changes from the latest stash without removing it from the stash stack. If you want to apply a specific stash other than the latest one, you need to specify its reference along with the command (git stash apply stash@{n}).

git stash apply stash@{n}

Applies a specific stash indexed by its number.

C:\Users\xyz\demo2>git stash apply stash@{1}        

On branch master
Changes to be committed:
  (use "git restore --staged <file>..." to unstage)
        new file:   addaccount.html
        new file:   index.html        

git stash pop

Applies the most recent stash and removes it from the stash list.

C:\Users\xyz\demo2> echo > gifts.html
C:\Users\xyz\demo2> git add .
C:\Users\xyz\demo2> >git stash save "added deals and gifts"
Saved working directory and index state On master: added deals and gifts        

C:\Users\xyz\demo2> git stash list
stash@{0}: On master: added deals and gifts
stash@{1}: WIP on master: 3e79938 after stash
stash@{2}: On master: added image and formC:\Users\xyz\demo2> git stash pop
On branch master
Changes to be committed:
  (use "git restore --staged <file>..." to unstage)
        new file:   gifts.htmlDropped refs/stash@{0} (db597c36729179d3094352b8c0cc21f32aa0bc7e)        

Dropping your stash

git stash drop

The git stash drop command by default drops the most recent stash in the stash stack.

C:\Users\xyz\demo2> git stash drop
Dropped refs/stash@{0} (5bf581c9b70d9191d12072749ca2c4da2e20df83)        

git stash drop stash@{n}

Removes a specific stash from the stash list without applying it.

C:\Users\xyz\demo2> git stash drop stash@{0}
Dropped stash@{0} (0ecd1ad995095a121f517e2cab116928ae4d590b)        

Clearing your Stash History

• Clears all stashed changes from the stash list.

C:\Users\xyz\demo2> git stash clear        

C:\Users\xyz\demo2>git stash list
C:\Users\xyz\demo2>        

nothing will be listed if we issue git stash list command as all stashes were cleared. This action is irreversible, so use it with caution.

Handling Stash Conflicts and Errors

Let’s say you’ve stashed some changes using git stash. Later, when you try to apply these changes using git stash apply, you encounter a conflict with the current state of your working directory. Git notifies you about the conflict and marks the conflicted files. To resolve the conflict, you need to manually edit the conflicted files, resolve the differences, and then mark the conflicts as resolved using git add.

Once you’ve resolved the conflicts, you can finalize the stash application by running git stash drop to remove the applied stash from the stack. This process ensures that your changes are successfully applied and integrated into your codebase without causing disruptions or errors.

Example: Suppose you’re actively working on a feature branch named feature-branch and encounter conflicts when applying stashed changes. Both feature-branch and master branches already contain a file named Admin.java.

C:\Users\xyz\demo2> git add .
C:\Users\xyz\demo2> git stash save "Work in Progress"
Saved working directory and index state On master: Work in Progress        

Pre-Conflict State (Before Pulling Changes from Master):

Admin.java in feature-branch:

public class Admin {
    public void featureMethod() {
        // Feature-branch changes
    }
}        

Pulling Changes from Master Branch:

C:\Users\xyz\demo2> git checkout master
Switched to branch master        

Admin.java in master:

public class Admin {
    public void masterMethod() {
        // Master branch changes
    }
}        

Conflict Occurs when Applying Stashed Changes:

Auto-merging Admin.java
CONFLICT (content): Merge conflict in Admin.java        

Admin.java (During Conflict):

public class Admin {
<<<<<<< HEAD (Changes from feature-branch)
    public void featureMethod() {
        // Feature-branch changes
=======
    public void masterMethod() {
        // Master branch changes
>>>>>>> master
    }
}        

Resolving Conflict (Resolved Admin.java):

we need to manually resolve the conflict based on which we feel is correct as per our business requirement. So the corrected outcome will look like this:

public class Admin {
    public void featureMethod() {
        // Feature-branch changes
    }
    public void masterMethod() {
        // Master branch changes
    }
}        

Then add file to stage and commit it . If you wanna keep the stash keep it or drop it.

git add Admin.java
git commit -m "Resolved conflicts in Admin.java"        

Conclusion:

In conclusion, Git stash stands as a ?? invaluable tool for managing temporary changes in your working directory. It empowers developers to store work-in-progress seamlessly, preserving the integrity of their codebase while facilitating task switching and conflict resolution. Leveraging Git stash effectively enhances productivity and ensures a streamlined workflow in software development projects. Its versatility and ease of use make it a ??? cornerstone feature in the Git ecosystem, empowering teams to collaborate efficiently and deliver high-quality code. Successfully integrating Git stash ignites the pathway to success, illuminating the journey with ?? fireworks of seamless development.