Git Stash temporarily shelves (or sguardhes) changes you’ve made to your working copy so you can work on something else, and then come back and reapply them later. Stashing is useful if you need to quickly change context and work on something else, but you’re halfway through a code change and not ready to compromise.
Git Storage Save your work
-
- Reapply saved changes
- Storing untracked or ignored files
- Managing
- Partial guijos
- Create a branch from the
- Cleaning up the
- How git
- Save
multiple caches Viewing stash differences
stash
stash
stash works
your work
The git stash command takes uncommitted changes (both temporary and non-tentative), saves them for later use, and then rolls them back from the working copy. For example
:
At this point, you are free to make changes, create new commits, change branches, and perform any other Git operation; then go back and reapply
your stash when you’re ready. Note that the stash is
local to your Git repository; the stash is not transferred to the server when it is pushed.
Reapply saved changes You can
reapply previously saved
changes
using git stash pop:
Blowing up
your stash removes the changes from your stash and reapplies them to your working copy. Alternatively, you can reapply the changes to your
working copy and keep them in your stash with git stash
apply:
This is useful if you want to apply the same hidden changes to multiple branches.
Now that you know the basics of storage, there’s a caveat with Git Stash that you should be aware of: by default, Git will not hide changes made to untracked or ignored files.
Storage of
untracked or
ignored files
By default, running git stash will be
hidden: changes that have been
- added to the index (preconfigured changes) changes made to files that
- Git is currently tracking (unconfigured changes)
But it won’t be hidden:
- new files in your working copy that haven’t been configured yet. Files that have been
- ignored
So if we add a third file to our previous example, but don’t prepare it (i.e. we don’t run git add), git stash won’t save it.
Adding the -u (or -include-untracked) option tells git stash
to save your untracked files as well:
You can also include changes to ignored files by passing the -a (or -all) option when running git stash.
Managing multiple caches
You are not limited to a single stash. You can run git stash multiple times to create multiple sguardhes, and then use git stash list to view them. By default, caches are simply identified as a “WIP” (work in progress) at the top of the branch and confirm that you created the stash from which you created. After a while it can be difficult to remember what each stash contains
:
To provide a little more context, it’s good practice to annotate your stash with a description, using
git stash save “message”:
By default, git stash pop will reapply the most recently created stash: stash@{0}
You can choose which stash to reapply by passing its identifier as the last argument, For example
: Viewing stash differences You can view a summary of a
stash with git
stash show:
Or pass the -p (or -patch) option to see the full difference
of a
stash
:
Partial stash You
can also choose to save a single file, a collection of files, or individual changes from within the files. If you pass the -p (or -patch) option to git stash, it will iterate through each changed “hunk” in your working copy and ask if you want to save it:
Can you press ? for a complete list of hunk commands. Commonly useful are:
Command description / search for a piece by regex ? help n don’t stash this hunk q quit (any piece that has already been selected will be saved) s divide this piece into smaller pieces and save this piece
There is no explicit “abort” command, but pressing CTRL-C (SIGINT) will abort the hiding process.
Create a
branch from the stash If the changes in your
branch diverge from the changes in your stash, You may have conflicts when blowing up or applying your stash. Instead, you can use the git
stash branch to create a new branch to apply hidden changes to:
This extracts a new branch based on the confirmation from which you created your cache, and then places the saved changes into it.
Cleaning your
stash
If you decide you no longer need a particular stash, You can remove it
with git stash drop: Or you can
delete all your stash with:
How git
stash works
If you just wanted to know how to use git stash, you can stop reading here. But if you’re curious about how Git (and git stash) works under the hood, read on!
The caches are actually encoded in your repository as commit objects. The special reference in .git/refs/stash points to your most recently created stash, and previously created stash is referenced by the stash reflog. This is why you refer to stash by stash@{n}: you actually mean the umpteenth reflog entry for the stash reference. Since a stash is just a commit, you can inspect it with git log:
depending on what you’ve saved, a single git stash operation creates two or three new commits. The commits in the diagram above are:
stash@{0}, a new commit to store the crawled files that were in your working copy when you ran git stash stash@{0} the first parent, the
- pre-existing commit that was
- in
- stash@{0} second parent, a new commit that
- represents the index when you ran git stash
- stash@{0} third parent, a new commit representing the untracked files that were in your working copy when you ran git stash. This third parent was only created if:
- your working copy actually contained untracked files; and
- specified the -include-untracked or -all option when you invoked git stash.
you
HEAD when you ran git stash
How git stash encodes your work tree and index as commits:
-
Before saving, your work tree can contain changes to crawled files, untracked files, and ignored files. Some of these changes may also be in the index.
-
The git stash invocation encodes any changes to tracked files as two new commits to the DAG: one for non-preconfigured changes and one for interim changes to the index. The special reference refs/stash is updated to point to them.
-
include-untracked option also encodes any changes to untracked
-
ignored files along with changes to untracked files in the same commit.
When you run git stash pop, changes from previous commits are used to update your working copy and index, and the fallback record is shuffled to remove the pop-up commit.
Using the –
files as an additional confirmation. Using the -all option includes changes to
Note that pop-up confirmations are not immediately deleted, but become candidates for future garbage collection.
