How to stash only unstaged changes in Git?
GitGit StashGit Problem Overview
I would like to use this workflow:
- Stage some changes.
- Save the unstaged changes to the stash.
- Do some stuff with the things in stage (build, test, etc.).
- Commit.
- Restore the unstaged changes.
Is there a way to do step 2?
Example:
git init
echo one >file
git add file
git commit
echo two >>file
git add file
echo three >>file
git stash push
test
git commit
git stash pop
Git Solutions
Solution 1 - Git
git stash push has an option --keep-index that does exactly what you need.
So, run git stash push --keep-index.
Solution 2 - Git
This may be done in 3 steps: save staged changes, stash everything else, restore index with staged changes. Which is basically:
git commit -m 'Save index'
git stash push -u -m 'Unstaged changes and untracked files'
git reset --soft HEAD^
This will do exactly what you want.
Solution 3 - Git
git stash save --keep-index
Also, Re:
> Why not commit your changes after staging them? – Shin
A: Because you should always checkin tested code :) That means, you need to run the tests with only the changes you are about to commit
All this apart from the fact that of course, as an experienced programmer, you have the innate urge to test and review just those changes -- only partly kidding
Solution 4 - Git
Stash Without the Staged Changes
The Problem with --keep-index / -k
Stashing just the working tree (unstaged changes) in Git is more difficult than it should be. The accepted answer, and quite a few other answers, stashes the unstaged changes and leaves the stage alone as requested via --keep-index.
However what isn't obvious is that --keep-index also stashes the staged changes. The staged changes end up in both the stage AND the stash. This is rarely what one wants because any interim changes to the stash are likely to result in conflicts when popping the stash later.
Alias Solution
This alias works well to stage just the working copy changes:
stash-working = "!f() { \
git commit --quiet --no-verify -m \"temp for stash-working\" && \
git stash push \"$@\" && \
git reset --quiet --soft HEAD~1; }; f"
It commits the staged changes temporarily, creates a stash from the remaining changes (and allows additional arguments such as --include-untracked and --message to be passed as alias arguments), and then resets the temporary commit to get back the staged changes.
It is similar to @Simon Knapp's answer, but with a few minor differences -- it uses --quiet on the temporary actions taken, and it accepts any number of parameters for the stash push, rather than hard-coding the -m, and it does add --soft to the final reset so that the index remains as it started. It also uses --no-verify on the commit to avoid changes to the working copy from pre-commit hooks (HT: @Granfalloner).
For the opposite problem of stashing just the staged changes (alias stash-index) see this answer.
Solution 5 - Git
With git version 2.7.4 you may do:
git stash save --patch
The git will ask you to add or not your changes into stash.
And you then just answer y or n
You can restore working directory as you always do that:
git stash pop
or, if you want to keep saved changes in stash:
git stash apply
Solution 6 - Git
To add the unstagged (not added to commit) files to stash, run the following command:
git stash -k
If you want to include newly added files(which is not staged - not in green) also to the stash, do the following:
git stash -k -u
Then you can commit the staged files. After that you can get back the last stashed files using the command:
git stash pop
Solution 7 - Git
From Git 2.35+ (Q1 2022) you can now use the --staged flag (man) on git stash push to only stage the changes in your index.
Since your question asks the exact opposite, we have 2 choices:
- Reverse the operation like so:
git stash push --staged # Stash staged changes
git stash # Stash everything else
git stash pop stash@{1} # Restore staged changes stash
- Stage the changes you want to stash instead of the ones you want to keep. Now you can just run:
git stash push --staged
I got this information from this answer on another S/O post.
Solution 8 - Git
Extending previous answers, I sometimes have a complex set of changes staged, but wish to commit a separate change first. For example, I might have spotted a bug or otherwise incorrect code that I'd like to fix ahead of my staged changes. One possible route to take is this:
first stash everything, but leave the staged changes intact > $ git stash save --keep-index [--include-untracked]
now stash the staged changes separately too > $ git stash save
make changes for fix; and test; commit them: > $ git add [--interactive] [--patch] > > $ git commit -m"fix..."
now restore the previously staged changes: > $ git stash pop
resolve any conflicts, and note that if there were conflicts, git will have applied but not dropped that top stash entry.
(... Then commit the staged changes, and restore the stash of all the other changes, and continue ...)
Solution 9 - Git
Git doesn't have a command that stashes only your unstaged changes.
Git does, however, let you specify which files you want to stash.
git stash push --message 'Unstaged changes' -- app/controllers/products_controller.rb test/controllers/products_controller_test.rb
If you only want to stash specific changes in those files, add the --patch option.
git stash push --patch --message 'Unstaged changes' -- app/controllers/products_controller.rb test/controllers/products_controller_test.rb
The --include-untracked option lets you stash untracked files.
git stash push --include-untracked --message 'Untracked files' -- app/controllers/widgets_controller.rb test/controllers/widgets_controller_test.rb
Run git help stash (or man git-stash) for more info.
Note: If your unstaged changes are rather disoganized, @alesguzik's answer is probably easier.
Solution 10 - Git
Another tip, related to the question:
When you effectively stash your unstaged changes using
> $ git stash save --keep-index
you might wish to give the stash a message, so that when you to do a git stash list it's more obvious what you have stashed before, especially if you follow that stash operation by further saves. For example
> $ git stash save --keep-index "changes not yet staged"
(although actually it does contain all the changes as noted in other answers).
For example, the above might be followed immediately by:
> $ git stash save "staged changes for feature X"
Beware, though, that you can't then use
> $ git stash apply "stash@{1}" ### ✘ doesn't quite do what you might want
to restore just the unstaged changes.
Solution 11 - Git
I use an an alias, which accepts a string to use as a message to the stash entry.
mystash = "!f() { git commit -m hold && git stash push -m \"$1\" && git reset HEAD^; }; f"
Which:
- commits everything in the index,
- stashes what is changed in the working tree (could of course add
-uor-a), - resets the last commit back to the working try (may want to use
--softto keep it in the index).
Solution 12 - Git
2022: I mention in "Stashing only staged changes in git - is it possible?", Git 2.35 (Q1 2022) comes with "git stash push --staged"(man):
> This option is only valid for push and save commands.
>
> Stash only the changes that are currently staged.
This is similar to basic git commit except the state is committed to the stash instead of current branch.
2019: The modern form of that command is git stash push [--] [<pathspec>...], since Git 2.16+ (git stash save is deprecated)
You can combine that with a wildcard form, for example:
git stash push --all --keep-index ':(glob)**/*.testextension'
But that does not work well with Git for Windows, until Git 2.22 (Q2 2019), see issue 2037, considering git stash has been re-implemented in C (instead of a shell script)
See commit 7db9302 (11 Mar 2019) by Thomas Gummerer (tgummerer).
See commit 1366c78, commit 7b556aa (07 Mar 2019) by Johannes Schindelin (dscho).
(Merged by Junio C Hamano -- gitster -- in commit 0ba1ba4, 22 Apr 2019)
> built-in stash: handle :(glob) pathspecs again
>
> When passing a list of pathspecs to, say, git add, we need to be
careful to use the original form, not the parsed form of the pathspecs.
>
> This makes a difference e.g. when calling
>
> git stash -- ':(glob)/*.txt'
>
> where the original form includes the :(glob) prefix while the parsed
form does not.
>
> However, in the built-in git stash, we passed the parsed (i.e. incorrect) form, and git add would fail with the error message:
>
> fatal: pathspec '/*.txt' did not match any files
>
> at the stage where git stash drops the changes from the worktree, even if refs/stash has been actually updated successfully.
Solution 13 - Git
Here's (in my opinion) the best solution, that does exactly what the OP has asked for. It stashes only the unstaged, tracked files – without an unnecessary commit or stashing all changed files with --keep-index
It lists all the unstaged, tracked changes (git diff --name-only) converts newlines to spaces (| tr '\n' ' ') and stashes all these files using git stash push:
git stash push $(git diff --name-only | tr '\n' ' ')
Solution 14 - Git
To my knowledge, it is currently impossible to save only unstaged changes in the working tree with git stash push, i.e. to save changes from the index state. This command saves all changes in the working tree (staged and unstaged changes), i.e. changes from the HEAD state, even with the option --keep-index which also sets the working tree state to the index state instead of the HEAD state (thereby creating conflicts when restoring the changes from the HEAD state with git stash pop). It would be very convenient if git stash push had an option -U|--unstaged for saving only unstaged changes (to me the option --keep-index is flawed), since it has already an option -S|--staged for saving only staged changes.
So for the moment you have to emulate
git stash push --unstaged
git stash pop
with a temporary file:
git diff >unstaged
git restore .
git apply unstaged
rm unstaged
Your use case is testing before committing partial changes and it is already in the reference documentation, but with the flawed option --keep-index which creates conflicts. Here is the version with the emulated option -U|--unstaged:
git init
echo one >file
git add file
git commit
echo two >>file
git add file
echo three >>file
git diff >unstaged
git restore .
test
git commit
git apply unstaged
rm unstaged
Visualising states
For a better understanding of stashing, I think it is important to look at the states of the working tree, index and HEAD at each step. Let’s take your use case.
git init
| working | index | HEAD |
|---|
echo one >file
| working | index | HEAD |
|---|---|---|
| one |
git add file
| working | index | HEAD |
|---|---|---|
| one | one |
git commit
| working | index | HEAD |
|---|---|---|
| one | one | one |
echo two >>file
| working | index | HEAD |
|---|---|---|
| one | one | one |
| two |
git add file
| working | index | HEAD |
|---|---|---|
| one | one | one |
| two | two |
echo three >>file
| working | index | HEAD |
|---|---|---|
| one | one | one |
| two | two | |
| three |
git diff >unstaged
git restore .
| working | index | HEAD |
|---|---|---|
| one | one | one |
| two | two |
test
git commit
| working | index | HEAD |
|---|---|---|
| one | one | one |
| two | two | two |
git apply unstaged
rm unstaged
| working | index | HEAD |
|---|---|---|
| one | one | one |
| two | two | two |
| three |