Stashing only staged changes in git - is it possible

Question

Is there a way I can stash just my staged changes  The scenario I m having issues with is when I ve worked on several bugs at a given time  and have several unstaged changes  I d like to be able to stage these files individually  create my  patch files  and stash them away until the code is approved  This way  when it s approved I can stash my entire  current  session  pop that bug and push the code   Am I going about this the wrong way  Am I misunderstanding how git can work in other ways to simplify my process

User · Answer

With latest git you may use --patch option git stash push --patch     since 2 14 6  git stash save --patch     for older git versions  And git will ask you for each change in your files to add or not into stash  You just answer y or n UPD Alias for DOUBLE STASH  git config --global alias stash-staged   bash -c  quot git stash --keep-index  git stash push -m  quot staged quot  --keep-index  git stash pop stash  1  quot    Now you can stage your files and then run git stash-staged  As result your staged files will be saved into stash  If you do not want to keep staged files and want move them into stash  Then you can add another alias and run git move-staged  git config --global alias move-staged   bash -c  quot git stash-staged git commit -m  quot temp quot   git stash  git reset --hard HEAD   git stash pop quot

User · Answer

TL DR Just add --   git diff --staged --name-only  for your git  lt pathspec gt  parameter   Here is a simple one-liner   git stash --   git diff --staged --name-only    And to add a message simply   git stash push -m  My work in progress  --   git diff --staged --name-only       Tested on v2 17 1 and v2 21 0 windows 1      Limitations           Please be aware that this will stash every single thing  if you have no files staged    Also if you have a file that is only partially staged   i e  only some changed lines  are staged while some other changed lines are not   then   the whole file will get stashed  including unstaged lines

User · Answer

I haven t seen this solution that requires no use of git stash   You don t even need to use git stash at all  You can work this out using a dedicated branch as covered here  branches are cheap   Indeed  you can isolate separately un- and staged changes with a few consecutive commands that you could bundle together into a git alias   Create and switch to an new branch where you ll commit separately staged and unstaged changes   see here At any moment you can git cherry-pick -e one commit from the created branch to apply it where you want  -e to change its commit message   When you don t need it anymore  you can delete this  quot stash branch quot   You may have to use the -D option to force deletion  instead of the -d normal option  because said branch is not merged and git might consider that you risk losing data if you delete it  That is true if you haven t cherry-picked commits that were on it before deletion   git branch -D separated-stashes  You can also add an alias to your    gitconfig in order to automate this behavior   git config --global alias bratisla   git switch -c separated-stashes  git commit -m  quot staged changes quot   git add -u  git commit -m  quot unstaged changes quot   git switch -    why this name     youtu be LpE1bJp8-4w  before  quot stashing quot  after  quot stashing quot    Of course  you can also achieve the same result using two consecutive stashes As stated in other answers  you have some ways to stash only unstaged or only staged changes using git stash  -k --keep-index  in combination with other commands  I personally find the -k option very confusing  as it stashes everything but keeps staged changes in staged state  that explains why  quot --keep-index quot    Whereas stashing something usually moves it to a stash entry  With -k the unstaged changes are stashed normally  but staged ones are just copied to the same stash entry   Step 0   you have two things in your git status   a file containing staged changes  and another one containing unstaged changes  Step 1   stash unstaged   staged changes but keep the staged ones in the index   git stash -k -m  quot all changes quot   The -m  quot     quot  part is optional  git stash -k is actually an alias for git stash push -k  that does not push anything remotely btw don t worry  which accepts a -m option to label you stash entries for clarity  like a commit message or a tag but for a stash entry   It is the newer version of the deprecated git stash save   Step 1bis  optional    git stash  Stash staged changes  that are still in the index   This step is not necessary for the following  but shows that you can put only staged changes in a stash entry if you want to  If you use this line you have to git stash  pop apply   amp  amp  git add -u before continuing on step 2   Step 2   git commit -m  quot staged changes quot   Makes a commit containing only staged changes from step 0  it contains the same thing as the stash entry from step 1bis   Step 3   git stash  pop apply   Restores the stash from step 1  Note that this stash entry contained everything  but since you already committed staged changes  this stash will only add unstaged changes from step 0  nb   quot restore quot  here does NOT mean  quot git restore quot   which is a different command   Step 4   git add -u  Adds the popped stash s content to the index  Step 5   git commit -m  quot unstaged changes quot    quot Unstaged quot  here  as  quot staged quot  in steps 2 and 3 s comments  refers to step 0  You are actually staging and committing the  quot staged changes quot  from step 0   Done   You now have two separated commits containing  un staged changes from step 0  You may want to amend rebase them for either additional changes or to rename drop squash them  Depending on what you did with your stash s stack  pop or apply   you might also want to git stash  drop clear  it  You can see you stash entries with git stash  list show

User · Answer

Stashing just the index  staged changes  in Git is more difficult than it should be  I ve found  Joe s answer to work well  and turned a minor variation of it into this alias   stash-index     f         git stash push --quiet --keep-index -m   temp for stash-index    amp  amp      git stash push         amp  amp      git stash pop --quiet stash  1   amp  amp      git stash show -p   git apply -R     f    It pushes both the staged and unstaged changes into a temporary stash  leaving the staged changes alone  It then pushes the staged changes into the stash  which is the stash we want to keep  Arguments passed to the alias  such as --message  whatever  will be added to this stash command  Finally  it pops the temporary stash to restore the original state and remove the temporary stash  and then finally  removes  the stashed changes from the working directory via a reverse patch application   For the opposite problem of stashing just the unstaged changes  alias stash-working  see this answer

User · Answer

Why don t you commit the change for a certain bug and create a patch from that commit and its predecessor     hackhackhack  fix two unrelated bugs git add -p                     add hunks of first bug git commit -m  fix bug  123    create commit  1 git add -p                     add hunks of second bug git commit -m  fix bug  321    create commit  2   Then  to create the appropriate patches  use git format-patch   git format-patch HEAD     This will create two files  0001-fix-bug-123 patch and 0002-fix-bug-321 patch  Or you can create separate branches for each bug  so you can merge or rebase bug fixes individually  or even delete them  if they don t work out

User · Answer

TL DR  git stash-staged   After creating an alias   git config --global alias stash-staged   bash -c  git stash --    git diff --staged --name-only      Here git diff returns list of --staged files --name-only And then we pass this list as pathspec to git stash commad   From man git stash   git stash  --    lt pathspec gt        lt pathspec gt        The new stash entry records the modified states only for the files    that match the pathspec  The index entries and working tree    files are then rolled back to the state in HEAD only for these    files  too  leaving files that do not match the pathspec intact

User · Answer

To prune an accidental change  especially the deletion of multiple files  do the following   git add  lt stuff to keep gt   amp  amp  git stash --keep-index  amp  amp  git stash drop   in other words  stash the crap and throw it away with the stash altogether   Tested in git version 2 17 1

User · Answer

Another approach to this is to create a temporary commit with files you don t want to be stashed  then stash remaining files and gently remove last commit  keeping the files intact  git add  files that you don t want to be stashed  git commit -m  quot temp quot  git stash --include-untracked git reset --soft HEAD 1  That way you only touch files that you want to be touched  Note   quot --include-untracked quot  is used here to also stash new files  which is probably what you really want

User · Answer

Is it absolutely necessary to work on several bugs at once   And by  at once   I mean  having files edited for multiple bugs at the same time     Because unless you absolutely need that  I d only work on one bug at a time in your environment   That way you can use local branches  amp  rebase  which I find far easier than managing a complex stash stage   Let s say master is at commit B    Now work on bug  1   git checkout -b bug1   Now you re on branch bug1   Make some changes  commit  wait for code review   This is local  so you re not affecting anyone else  and it should be easy enough to make a patch from git diffs   A-B  lt  master          C  lt  bug1   Now you re working on bug2  Go back to master with git checkout master    Make a new branch  git checkout -b bug2   Make changes  commit  wait for code review       D  lt  bug2      A-B  lt  master          C  lt  bug1   Let s pretend that someone else commits E  amp  F on master while you re waiting on review         D  lt  bug2      A-B-E-F  lt  master          C  lt  bug1   When your code has been approved  you can rebase it on to master with the following steps   git checkout bug1 git rebase master git checkout master git merge bug1   This will result in the following       D  lt  bug2      A-B-E-F-C   lt  master  bug1   Then you can push  delete your local bug1 branch  and off you go   One bug at a time in your workspace  but with using local branches your repository can handle multiple bugs   And this avoids a complicated stage stash dance   Answer to ctote s question in the comments   Well  you can go back to stashing for each bug  and only work with one bug at a time   Atleast that saves you the staging issue   But having tried this  I personally find it troublesome   Stashes are a bit messy in a git log graph   And more importantly  if you screw something up you can t revert   If you have a dirty working directory and you pop a stash  you can t  undo  that pop   It s much harder to screw up already existing commits   So git rebase -i   When you rebase one branch onto another  you can do it interactively  the -i flag    When you do this  you have the option to pick what you want to do with each commit   Pro Git is an awesome book which is also online in HTML format  and has a nice section on rebasing  amp  squashing   http   git-scm com book ch6-4 html  I ll steal their example verbatim for convenience   Pretend you have the following commit history  and you want to rebase  amp  squash bug1 onto master       F  lt  bug2      A-B-G-H  lt  master          C-D-E  lt  bug1   Here s what you will see when you type git rebase -i master bug1  pick f7f3f6d changed my name a bit pick 310154e updated README formatting and added blame pick a5f4a0d added cat-file     Commands     p  pick   use commit    e  edit   use commit  but stop for amending    s  squash   use commit  but meld into previous commit     If you remove a line here THAT COMMIT WILL BE LOST    However  if you remove everything  the rebase will be aborted      To squash all commits of a branch down into a single commit  keep the first commit as  pick  and replace all subsequent  pick  entries with  squash  or simply  s    You will get the opportunity to change the commit message  too   pick f7f3f6d changed my name a bit s 310154e updated README formatting and added blame s a5f4a0d added cat-file     Commands     p  pick   use commit    e  edit   use commit  but stop for amending    s  squash   use commit  but meld into previous commit   So yeah  squashing is a bit of a pain  but I would still recommend it over heavy use of stashes

User · Answer

Out of your comments to Mike Monkiewicz answer I suggest to use a simpler model  Use regular development branches  but use the squash option of the merge to get a single commit in your master branch   git checkout -b bug1      create the development branch   hack hack hack          do some work git commit   hack hack hack   git commit   hack hack hack   git commit   hack hack hack   git commit git checkout master       go back to the master branch git merge --squash bug1   merge the work back git commit                commit the merge  don t forget                              to change the default commit message  git branch -D bug1        remove the development branch   The advantage of this procedure is that you can use the normal git work flow

User · Answer

I made a script that stashes only what is currently staged and leaves everything else   This is awesome when I start making too many unrelated changes   Simply stage what isn t related to the desired commit and stash just that    Thanks to Bartlomiej for the starting point      bin bash   Stash everything temporarily   Keep staged files  discard everything else after stashing  git stash --keep-index   Stash everything that remains  only the staged files should remain   This is the stash we want to keep  so give it a name  git stash save   1    Apply the original stash to get us back to where we started  git stash apply stash  1    Create a temporary patch to reverse the originally staged changes and apply it git stash show -p   git apply -R   Delete the temporary stash git stash drop stash  1

User · Answer

In this scenario  I prefer to create new branches for each issue  I use a prefix temp  so I know that I can delete these branches later   git checkout -b temp bug1   Stage the files that fix bug1 and commit them   git checkout -b temp bug2   You can then cherry pick the commits from the respective branches as require and submit a pull request

User · Answer

git stash --keep-index is a good solution    except it did not work correctly on paths that have been removed  which has been fixed in Git 2 23  Q3 2019   See commit b932f6a  16 Jul 2019  by Thomas Gummerer  tgummerer    Merged by Junio C Hamano -- gitster -- in commit f8aee85  25 Jul 2019        stash  fix handling removed files with --keep-index      git stash push --keep-index is supposed to keep all changes that have   been added to the index  both in the index and on disk       Currently this doesn t behave correctly when a file is removed from the index    Instead of keeping it deleted on disk    --keep-index currently restores the file         Fix that behaviour by using  git checkout  in no-overlay mode which   can faithfully restore the index and working tree    This also simplifies the code       Note that this will overwrite untracked files if the untracked file has the same name as a file that has been deleted in the index

User · Answer

To accomplish the same thing      Stage just the files you want to work on  git commit -m  temp  git add   git stash git reset HEAD 1   Boom   The files you don t want are stashed   The files you want are all ready for you

User · Answer

Yes  It s possible with DOUBLE STASH   Stage all your files that you need to stash  Run git stash --keep-index  This command will create a stash with ALL of your changes  staged and unstaged   but will leave the staged changes in your working directory  still in state staged   Run git stash push -m  good stash  Now your  good stash  has ONLY staged files     Now if you need unstaged files before stash  simply apply first stash  the one created with --keep-index  and now you can remove files you stashed to  good stash    Enjoy

[git] Stashing only staged changes in git - is it possible?

Examples related to git

Examples related to git-stash