# git-stash

## NAME



           git-stash - Stash the changes in a dirty working directory away
    


## SYNOPSIS



           _git stash_ list [<log-options>]
           _git stash_ show [-u | --include-untracked | --only-untracked] [<diff-options>] [<stash>]
           _git stash_ drop [-q | --quiet] [<stash>]
           _git stash_ pop [--index] [-q | --quiet] [<stash>]
           _git stash_ apply [--index] [-q | --quiet] [<stash>]
           _git stash_ branch <branchname> [<stash>]
           _git stash_ [push [-p | --patch] [-S | --staged] [-k | --[no-]keep-index] [-q | --quiet]
                        [-u | --include-untracked] [-a | --all] [(-m | --message) <message>]
                        [--pathspec-from-file=<file> [--pathspec-file-nul]]
                        [--] [<pathspec>...]]
           _git stash_ save [-p | --patch] [-S | --staged] [-k | --[no-]keep-index] [-q | --quiet]
                        [-u | --include-untracked] [-a | --all] [<message>]
           _git stash_ clear
           _git stash_ create [<message>]
           _git stash_ store [(-m | --message) <message>] [-q | --quiet] <commit>
           _git stash_ export (--print | --to-ref <ref>) [<stash>...]
           _git stash_ import <commit>
    


## DESCRIPTION



           Use **git stash** when you want to record the current state of the
           working directory and the index, but want to go back to a clean
           working directory. The command saves your local modifications away
           and reverts the working directory to match the **HEAD** commit.
    
           The modifications stashed away by this command can be listed with
           **git stash list** , inspected with **git stash show** , and restored
           (potentially on top of a different commit) with **git stash apply**.
           Calling **git stash** without any arguments is equivalent to **git stash**
           **push**. A stash is by default listed as "WIP on _branchname_ ...", but
           you can give a more descriptive message on the command line when
           you create one.
    
           The latest stash you created is stored in **refs/stash** ; older
           stashes are found in the reflog of this reference and can be named
           using the usual reflog syntax (e.g. **stash@**{0} is the most recently
           created stash, **stash@**{1} is the one before it, **stash@**{2.hours.ago}
           is also possible). Stashes may also be referenced by specifying
           just the stash index (e.g. the integer **n** is equivalent to
           **stash@**{n}).
    


## COMMANDS



           push [-p|--patch] [-S|--staged] [-k|--[no-]keep-index]
           [-u|--include-untracked] [-a|--all] [-q|--quiet] [(-m|--message)
           <message>] [--pathspec-from-file=<file> [--pathspec-file-nul]]
           [--] [<pathspec>...]
               Save your local modifications to a new _stash entry_ and roll
               them back to HEAD (in the working tree and in the index). The
               <message> part is optional and gives the description along
               with the stashed state.
    
               For quickly making a snapshot, you can omit "push". In this
               mode, non-option arguments are not allowed to prevent a
               misspelled subcommand from making an unwanted stash entry. The
               two exceptions to this are **stash -p** which acts as alias for
               **stash push -p** and pathspec elements, which are allowed after a
               double hyphen **--** for disambiguation.
    
           save [-p|--patch] [-S|--staged] [-k|--[no-]keep-index]
           [-u|--include-untracked] [-a|--all] [-q|--quiet] [<message>]
               This option is deprecated in favour of _git stash push_. It
               differs from "stash push" in that it cannot take pathspec.
               Instead, all non-option arguments are concatenated to form the
               stash message.
    
           list [<log-options>]
               List the stash entries that you currently have. Each _stash_
               _entry_ is listed with its name (e.g.  **stash@**{0} is the latest
               entry, **stash@**{1} is the one before, etc.), the name of the
               branch that was current when the entry was made, and a short
               description of the commit the entry was based on.
    
                   stash@{0}: WIP on submit: 6ebd0e2... Update git-stash documentation
                   stash@{1}: On master: 9cc0589... Add git-stash
    
               The command takes options applicable to the _git log_ command to
               control what is shown and how. See git-log(1).
    
           show [-u|--include-untracked|--only-untracked] [<diff-options>]
           [<stash>]
               Show the changes recorded in the stash entry as a diff between
               the stashed contents and the commit back when the stash entry
               was first created. By default, the command shows the diffstat,
               but it will accept any format known to _git diff_ (e.g., **git**
               **stash show -p stash@**{1} to view the second most recent entry
               in patch form). If no _< diff-option>_ is provided, the default
               behavior will be given by the **stash.showStat** , and
               **stash.showPatch** config variables. You can also use
               **stash.showIncludeUntracked** to set whether **--include-untracked**
               is enabled by default.
    
           pop [--index] [-q|--quiet] [<stash>]
               Remove a single stashed state from the stash list and apply it
               on top of the current working tree state, i.e., do the inverse
               operation of **git stash push**. The working directory must match
               the index.
    
               Applying the state can fail with conflicts; in this case, it
               is not removed from the stash list. You need to resolve the
               conflicts by hand and call **git stash drop** manually afterwards.
    
           apply [--index] [-q|--quiet] [<stash>]
               Like **pop** , but do not remove the state from the stash list.
               Unlike **pop** , _< stash>_ may be any commit that looks like a commit
               created by **stash push** or **stash create**.
    
           branch <branchname> [<stash>]
               Creates and checks out a new branch named _< branchname>_
               starting from the commit at which the _< stash>_ was originally
               created, applies the changes recorded in _< stash>_ to the new
               working tree and index. If that succeeds, and _< stash>_ is a
               reference of the form **stash@**{_< revision>_}, it then drops the
               _< stash>_.
    
               This is useful if the branch on which you ran **git stash push**
               has changed enough that **git stash apply** fails due to
               conflicts. Since the stash entry is applied on top of the
               commit that was HEAD at the time **git stash** was run, it
               restores the originally stashed state with no conflicts.
    
           clear
               Remove all the stash entries. Note that those entries will
               then be subject to pruning, and may be impossible to recover
               (see _Examples_ below for a possible strategy).
    
           drop [-q|--quiet] [<stash>]
               Remove a single stash entry from the list of stash entries.
    
           create
               Create a stash entry (which is a regular commit object) and
               return its object name, without storing it anywhere in the ref
               namespace. This is intended to be useful for scripts. It is
               probably not the command you want to use; see "push" above.
    
           store
               Store a given stash created via _git stash create_ (which is a
               dangling merge commit) in the stash ref, updating the stash
               reflog. This is intended to be useful for scripts. It is
               probably not the command you want to use; see "push" above.
    
           export ( --print | --to-ref <ref> ) [<stash>...]
               Export the specified stashes, or all of them if none are
               specified, to a chain of commits which can be transferred
               using the normal fetch and push mechanisms, then imported
               using the **import** subcommand.
    
           import <commit>
               Import the specified stashes from the specified commit, which
               must have been created by **export** , and add them to the list of
               stashes. To replace the existing stashes, use **clear** first.
    


## OPTIONS



           -a, --all
               This option is only valid for **push** and **save** commands.
    
               All ignored and untracked files are also stashed and then
               cleaned up with **git clean**.
    
           -u, --include-untracked, --no-include-untracked
               When used with the **push** and **save** commands, all untracked files
               are also stashed and then cleaned up with **git clean**.
    
               When used with the **show** command, show the untracked files in
               the stash entry as part of the diff.
    
           --only-untracked
               This option is only valid for the **show** command.
    
               Show only the untracked files in the stash entry as part of
               the diff.
    
           --index
               This option is only valid for **pop** and **apply** commands.
    
               Tries to reinstate not only the working tree’s changes, but
               also the index’s ones. However, this can fail, when you have
               conflicts (which are stored in the index, where you therefore
               can no longer apply the changes as they were originally).
    
           -k, --keep-index, --no-keep-index
               This option is only valid for **push** and **save** commands.
    
               All changes already added to the index are left intact.
    
           -p, --patch
               This option is only valid for **push** and **save** commands.
    
               Interactively select hunks from the diff between HEAD and the
               working tree to be stashed. The stash entry is constructed
               such that its index state is the same as the index state of
               your repository, and its worktree contains only the changes
               you selected interactively. The selected changes are then
               rolled back from your worktree. See the “Interactive Mode”
               section of git-add(1) to learn how to operate the **--patch**
               mode.
    
               The **--patch** option implies **--keep-index**. You can use
               **--no-keep-index** to override this.
    
           **-U** _< n>_, **--unified=**_< n>_
               Generate diffs with _< n>_ lines of context. Defaults to
               **diff.context** or 3 if the config option is unset.
    
           **--inter-hunk-context=**_< n>_
               Show the context between diff hunks, up to the specified
               _< number>_ of lines, thereby fusing hunks that are close to each
               other. Defaults to **diff.interHunkContext** or 0 if the config
               option is unset.
    
           -S, --staged
               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.
    
               The **--patch** option has priority over this one.
    
           --pathspec-from-file=<file>
               This option is only valid for **push** command.
    
               Pathspec is passed in _< file>_ instead of commandline args. If
               _< file>_ is exactly **-** then standard input is used. Pathspec
               elements are separated by LF or CR/LF. Pathspec elements can
               be quoted as explained for the configuration variable
               **core.quotePath**(see git-config(1)). See also
               **--pathspec-file-nul** and global **--literal-pathspecs**.
    
           --pathspec-file-nul
               This option is only valid for **push** command.
    
               Only meaningful with **--pathspec-from-file**. Pathspec elements
               are separated with NUL character and all other characters are
               taken literally (including newlines and quotes).
    
           -q, --quiet
               This option is only valid for **apply** , **drop** , **pop** , **push** , **save** ,
               **store** commands.
    
               Quiet, suppress feedback messages.
    
           --print
               This option is only valid for the **export** command.
    
               Create the chain of commits representing the exported stashes
               without storing it anywhere in the ref namespace and print the
               object ID to standard output. This is designed for scripts.
    
           --to-ref
               This option is only valid for the **export** command.
    
               Create the chain of commits representing the exported stashes
               and store it to the specified ref.
    
           --
               This option is only valid for **push** command.
    
               Separates pathspec from options for disambiguation purposes.
    
           <pathspec>...
               This option is only valid for **push** command.
    
               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.
    
               For more details, see the _pathspec_ entry in gitglossary(7).
    
           <stash>
               This option is only valid for **apply** , **branch** , **drop** , **pop** , **show** ,
               and **export** commands.
    
               A reference of the form **stash@**{_< revision>_}. When no _< stash>_ is
               given, the latest stash is assumed (that is, **stash@**{0}).
    


## DISCUSSION



           A stash entry is represented as a commit whose tree records the
           state of the working directory, and its first parent is the commit
           at **HEAD** when the entry was created. The tree of the second parent
           records the state of the index when the entry is made, and it is
           made a child of the **HEAD** commit. The ancestry graph looks like
           this:
    
                      .----W
                     /    /
               -----H----I
    
           where **H** is the **HEAD** commit, **I** is a commit that records the state
           of the index, and **W** is a commit that records the state of the
           working tree.
    


## EXAMPLES



           Pulling into a dirty tree
               When you are in the middle of something, you learn that there
               are upstream changes that are possibly relevant to what you
               are doing. When your local changes do not conflict with the
               changes in the upstream, a simple **git pull** will let you move
               forward.
    
               However, there are cases in which your local changes do
               conflict with the upstream changes, and **git pull** refuses to
               overwrite your changes. In such a case, you can stash your
               changes away, perform a pull, and then unstash, like this:
    
                   $ git pull
                    ...
                   file foobar not up to date, cannot merge.
                   $ git stash
                   $ git pull
                   $ git stash pop
    
           Interrupted workflow
               When you are in the middle of something, your boss comes in
               and demands that you fix something immediately. Traditionally,
               you would make a commit to a temporary branch to store your
               changes away, and return to your original branch to make the
               emergency fix, like this:
    
                   # ... hack hack hack ...
                   $ git switch -c my_wip
                   $ git commit -a -m "WIP"
                   $ git switch master
                   $ edit emergency fix
                   $ git commit -a -m "Fix in a hurry"
                   $ git switch my_wip
                   $ git reset --soft HEAD^
                   # ... continue hacking ...
    
               You can use _git stash_ to simplify the above, like this:
    
                   # ... hack hack hack ...
                   $ git stash
                   $ edit emergency fix
                   $ git commit -a -m "Fix in a hurry"
                   $ git stash pop
                   # ... continue hacking ...
    
           Testing partial commits
               You can use **git stash push --keep-index** when you want to make
               two or more commits out of the changes in the work tree, and
               you want to test each change before committing:
    
                   # ... hack hack hack ...
                   $ git add --patch foo            # add just first part to the index
                   $ git stash push --keep-index    # save all other changes to the stash
                   $ edit/build/test first part
                   $ git commit -m 'First part'     # commit fully tested change
                   $ git stash pop                  # prepare to work on all other changes
                   # ... repeat above five steps until one commit remains ...
                   $ edit/build/test remaining parts
                   $ git commit foo -m 'Remaining parts'
    
           Saving unrelated changes for future use
               When you are in the middle of massive changes and you find
               some unrelated issue that you don’t want to forget to fix, you
               can do the change(s), stage them, and use **git stash push**
               **--staged** to stash them out for future use. This is similar to
               committing the staged changes, only the commit ends-up being
               in the stash and not on the current branch.
    
                   # ... hack hack hack ...
                   $ git add --patch foo           # add unrelated changes to the index
                   $ git stash push --staged       # save these changes to the stash
                   # ... hack hack hack, finish current changes ...
                   $ git commit -m 'Massive'       # commit fully tested changes
                   $ git switch fixup-branch       # switch to another branch
                   $ git stash pop                 # to finish work on the saved changes
    
           Recovering stash entries that were cleared/dropped erroneously
               If you mistakenly drop or clear stash entries, they cannot be
               recovered through the normal safety mechanisms. However, you
               can try the following incantation to get a list of stash
               entries that are still in your repository, but not reachable
               any more:
    
                   git fsck --unreachable |
                   grep commit | cut -d\  -f3 |
                   xargs git log --merges --no-walk --grep=WIP
    


## CONFIGURATION



           Everything below this line in this section is selectively included
           from the git-config(1) documentation. The content is the same as
           what’s found there:
    
           stash.showIncludeUntracked
               If this is set to true, the **git stash show** command will show
               the untracked files of a stash entry. Defaults to false. See
               the description of the _show_ command in git-stash(1).
    
           stash.showPatch
               If this is set to true, the **git stash show** command without an
               option will show the stash entry in patch form. Defaults to
               false. See the description of the _show_ command in
               git-stash(1).
    
           stash.showStat
               If this is set to true, the **git stash show** command without an
               option will show a diffstat of the stash entry. Defaults to
               true. See the description of the _show_ command in git-stash(1).
    


## GIT



           Part of the git(1) suite
    


* * *