Mastering the Git Stash Command: A Comprehensive Guide

As a full-stack developer, you‘re likely juggling multiple features, bug fixes, and experiments in your Git repository at any given time. With so many plates spinning, it‘s essential to have tools that help you context switch quickly and manage in-progress work efficiently. One of the most powerful tools for this is the git stash command.

In this in-depth guide, we‘ll explore the git stash command and share expert tips and best practices for using it effectively in your development workflow. Whether you‘re a Git novice or a seasoned pro, you‘ll learn new ways to leverage stashes to stay organized and productive.

Why Use Git Stash?

Before diving into the mechanics of git stash, let‘s consider why and when you might reach for this tool. Here are some common scenarios:

1. Interruptions: You‘re deep in the zone implementing a complex feature when you receive an urgent request to fix a critical bug in production. You don‘t want to commit a half-finished feature, but you also don‘t want to lose your current changes. Solution: git stash your changes, switch to the main branch, fix the bug, then come back and git stash apply to pick up where you left off.

2. Syncing with teammates: You‘ve been working on a feature branch for a few days, but in the meantime, your teammates have merged several pull requests to the main branch. You want to integrate their changes into your feature branch to avoid conflicts down the road. Solution: git stash your changes, git pull the latest changes from main, then git stash pop to apply your changes on top.

3. Experimenting: You have an idea for refactoring a component, but you‘re not sure if it‘s going to pan out. You don‘t want to create a whole new branch for an experiment, but you also don‘t want to clutter your current branch with commits you may end up throwing away. Solution: git stash your experimental changes, try out your idea, and if it doesn‘t work out, simply git stash drop to discard the changes.

According to the 2021 Stack Overflow Developer Survey, Git is the most popular version control system, with 93.9% of professional developers using it. And among Git users, git stash is a widely used command. A quick search on GitHub reveals over 4 million occurrences of git stash in public repositories.

So, now that we understand the "why" behind git stash, let‘s explore the "how".

Stashing Changes

The basic syntax for stashing changes is:

git stash

This takes all uncommitted changes (staged and unstaged) in your working directory, bundles them up into a stash object, and reverts your working directory to the last commit. It‘s like a temporary "save point" for your work in progress.

Under the hood, git stash actually does a few things:

1. Moves your staged changes into the stash
2. Reverts unstaged changes in your working directory
3. Saves the current state of the stash stack refs

You can also provide a description for your stash to make it easier to identify later:

git stash save "Refactoring navbar component"

By default, git stash only stashes changes to tracked files (i.e., files that have been previously staged or committed). If you also want to stash changes to untracked files, use the -u (or --include-untracked) option:

git stash -u

Advanced Stashing Techniques

In addition to the basic git stash command, there are a few more advanced ways to stash changes.

Keeping Staged Changes

Sometimes you may want to stash only some of your changes, while keeping others staged. For example, suppose you‘ve staged some changes related to Feature A, but you also have unstaged changes related to Feature B. If you want to stash the Feature B changes without stashing the Feature A changes, you can use the --keep-index option:

git stash --keep-index

This will stash only the unstaged changes, leaving your staged changes intact.

Interactive Stashing

Git also provides an interactive mode for stashing, which allows you to select which hunks of changes to stash. To use this mode, run:

git stash --patch

This will open an interactive prompt where you can choose to stash (or not stash) each hunk of changes:

Stash this hunk [y,n,q,a,d,e,?]? y

This can be handy if you want to selectively stash certain changes while leaving others in your working directory.

Managing Multiple Stashes

One of the strengths of git stash is that it allows you to store multiple stashes on a stack. Each time you run git stash, a new entry is pushed onto the stack. You can view all stashes with:

git stash list

This will display a list of your saved stashes in the format stash@{n}, where n is the stash index starting at 0 for the most recent stash.

To apply the most recent stash and remove it from the stack, use:

git stash pop

If you want to apply a specific stash (e.g., stash@{2}), you can reference it directly:

git stash pop stash@{2}

If you want to apply a stash without removing it from the stack, use git stash apply instead of git stash pop.

Integrating Stashes into Your Workflow

Now that we‘ve covered the basics of using git stash, let‘s explore some best practices and workflows for incorporating stashes into your development process.

Stashing and Pull Requests

One common workflow is to use stashes when creating pull requests. Suppose you‘ve been working on a feature branch and are ready to open a pull request, but you have some uncommitted changes that aren‘t quite ready to include. You can git stash those changes, open your pull request, and then git stash pop the changes back into your working directory to continue working on them.

This keeps your pull requests focused and allows you to get feedback on completed work while still keeping in-progress changes safe.

Stashing and Code Reviews

Stashes can also be helpful during code reviews. If you‘re reviewing a teammate‘s pull request and want to test it out locally with your own changes, you can git stash your work, git checkout their branch, git pull their changes, then git stash pop your changes on top. This can be quicker than committing your changes or creating a new branch.

Resolving Conflicts

When you apply a stash, you may occasionally run into merge conflicts if the stashed changes overlap with changes in your working directory. Git will prompt you to resolve these conflicts before completing the stash apply.

To minimize conflicts, it‘s a good idea to git stash pop or git stash apply as soon as possible after stashing changes. The longer a stash sits around, the more likely it is to diverge from your current working directory.

If you do run into conflicts, you can use git status to see which files are affected and resolve the conflicts manually. Once you‘ve resolved the conflicts, you can git add the resolved files and continue the stash apply with git stash drop.

Stashing and Continuous Integration

If you‘re using a continuous integration (CI) system like Jenkins or TravisCI, you can also incorporate git stash into your build and deployment workflows. For example, you might have a script that automatically stashes any uncommitted changes before running your test suite, ensuring that your tests always run against a clean working directory.

Here‘s an example using a Bash script:

#!/bin/bash

# Stash any uncommitted changes
git stash --include-untracked

# Run the test suite
npm test

# Restore stashed changes
git stash pop

This script will stash any uncommitted changes (including untracked files), run the npm test command, and then pop the stashed changes back into the working directory.

When Not to Use Git Stash

While git stash is a powerful tool, it‘s not always the right choice. Here are a few situations where you might want to use a different approach:

1. Long-running stashes: If you have changes that you need to set aside for an extended period (e.g., several days or weeks), it‘s usually better to create a new branch for those changes instead of using git stash. Branches are more visible and easier to track over time.

2. Collaborative stashes: If you need to share changes with a teammate, it‘s better to commit those changes to a branch and push the branch to a remote repository. Stashes are local to your machine and can‘t be easily shared.

3. Stashing binaries: Git is designed for tracking text-based files like source code, not large binary files like images or videos. If you need to temporarily set aside changes to binary files, you may be better off using a separate tool or simply copying the files to a different location.

Conclusion

The git stash command is a versatile tool that every developer should have in their Git toolbox. Whether you‘re using it to context switch between features, collaborate with teammates, or experiment with new ideas, git stash can help you stay organized and productive.

By following the tips and best practices outlined in this guide, you can integrate git stash into your workflow and level up your Git skills. Remember to communicate with your team about your stashing practices, and don‘t be afraid to experiment with advanced techniques like interactive stashing or scripting.

Happy stashing!

Additional Resources

• Git stash documentation
• Oh Shit, Git!?! – a cheatsheet for common Git mistakes and how to fix them
• Git Stash Explained – a video tutorial on using git stash
• Git Stash Tips and Tricks – a collection of advanced git stash techniques
• How to Use Git Stash – an introductory guide to git stash on freeCodeCamp