1git-stash(1) 2============ 3 4NAME 5---- 6git-stash - Stash the changes in a dirty working directory away 7 8SYNOPSIS 9-------- 10[verse] 11'git stash' list [<options>] 12'git stash' show [<stash>] 13'git stash' drop [-q|--quiet] [<stash>] 14'git stash' ( pop | apply ) [--index] [-q|--quiet] [<stash>] 15'git stash' branch <branchname> [<stash>] 16'git stash' [save [-p|--patch] [-k|--[no-]keep-index] [-q|--quiet] 17 [-u|--include-untracked] [-a|--all] [<message>]] 18'git stash' clear 19'git stash' create [<message>] 20 21DESCRIPTION 22----------- 23 24Use `git stash` when you want to record the current state of the 25working directory and the index, but want to go back to a clean 26working directory. The command saves your local modifications away 27and reverts the working directory to match the `HEAD` commit. 28 29The modifications stashed away by this command can be listed with 30`git stash list`, inspected with `git stash show`, and restored 31(potentially on top of a different commit) with `git stash apply`. 32Calling `git stash` without any arguments is equivalent to `git stash save`. 33A stash is by default listed as "WIP on 'branchname' ...", but 34you can give a more descriptive message on the command line when 35you create one. 36 37The latest stash you created is stored in `refs/stash`; older 38stashes are found in the reflog of this reference and can be named using 39the usual reflog syntax (e.g. `stash@{0}` is the most recently 40created stash, `stash@{1}` is the one before it, `stash@{2.hours.ago}` 41is also possible). 42 43OPTIONS 44------- 45 46save [-p|--patch] [--[no-]keep-index] [-u|--include-untracked] [-a|--all] [-q|--quiet] [<message>]:: 47 48 Save your local modifications to a new 'stash', and run `git reset 49 --hard` to revert them. The <message> part is optional and gives 50 the description along with the stashed state. For quickly making 51 a snapshot, you can omit _both_ "save" and <message>, but giving 52 only <message> does not trigger this action to prevent a misspelled 53 subcommand from making an unwanted stash. 54+ 55If the `--keep-index` option is used, all changes already added to the 56index are left intact. 57+ 58If the `--include-untracked` option is used, all untracked files are also 59stashed and then cleaned up with `git clean`, leaving the working directory 60in a very clean state. If the `--all` option is used instead then the 61ignored files are stashed and cleaned in addition to the untracked files. 62+ 63With `--patch`, you can interactively select hunks from the diff 64between HEAD and the working tree to be stashed. The stash entry is 65constructed such that its index state is the same as the index state 66of your repository, and its worktree contains only the changes you 67selected interactively. The selected changes are then rolled back 68from your worktree. See the ``Interactive Mode'' section of 69linkgit:git-add[1] to learn how to operate the `--patch` mode. 70+ 71The `--patch` option implies `--keep-index`. You can use 72`--no-keep-index` to override this. 73 74list [<options>]:: 75 76 List the stashes that you currently have. Each 'stash' is listed 77 with its name (e.g. `stash@{0}` is the latest stash, `stash@{1}` is 78 the one before, etc.), the name of the branch that was current when the 79 stash was made, and a short description of the commit the stash was 80 based on. 81+ 82---------------------------------------------------------------- 83stash@{0}: WIP on submit: 6ebd0e2... Update git-stash documentation 84stash@{1}: On master: 9cc0589... Add git-stash 85---------------------------------------------------------------- 86+ 87The command takes options applicable to the 'git log' 88command to control what is shown and how. See linkgit:git-log[1]. 89 90show [<stash>]:: 91 92 Show the changes recorded in the stash as a diff between the 93 stashed state and its original parent. When no `<stash>` is given, 94 shows the latest one. By default, the command shows the diffstat, but 95 it will accept any format known to 'git diff' (e.g., `git stash show 96 -p stash@{1}` to view the second most recent stash in patch form). 97 98pop [--index] [-q|--quiet] [<stash>]:: 99 100 Remove a single stashed state from the stash list and apply it 101 on top of the current working tree state, i.e., do the inverse 102 operation of `git stash save`. The working directory must 103 match the index. 104+ 105Applying the state can fail with conflicts; in this case, it is not 106removed from the stash list. You need to resolve the conflicts by hand 107and call `git stash drop` manually afterwards. 108+ 109If the `--index` option is used, then tries to reinstate not only the working 110tree's changes, but also the index's ones. However, this can fail, when you 111have conflicts (which are stored in the index, where you therefore can no 112longer apply the changes as they were originally). 113+ 114When no `<stash>` is given, `stash@{0}` is assumed, otherwise `<stash>` must 115be a reference of the form `stash@{<revision>}`. 116 117apply [--index] [-q|--quiet] [<stash>]:: 118 119 Like `pop`, but do not remove the state from the stash list. Unlike `pop`, 120 `<stash>` may be any commit that looks like a commit created by 121 `stash save` or `stash create`. 122 123branch <branchname> [<stash>]:: 124 125 Creates and checks out a new branch named `<branchname>` starting from 126 the commit at which the `<stash>` was originally created, applies the 127 changes recorded in `<stash>` to the new working tree and index. 128 If that succeeds, and `<stash>` is a reference of the form 129 `stash@{<revision>}`, it then drops the `<stash>`. When no `<stash>` 130 is given, applies the latest one. 131+ 132This is useful if the branch on which you ran `git stash save` has 133changed enough that `git stash apply` fails due to conflicts. Since 134the stash is applied on top of the commit that was HEAD at the time 135`git stash` was run, it restores the originally stashed state with 136no conflicts. 137 138clear:: 139 Remove all the stashed states. Note that those states will then 140 be subject to pruning, and may be impossible to recover (see 141 'Examples' below for a possible strategy). 142 143drop [-q|--quiet] [<stash>]:: 144 145 Remove a single stashed state from the stash list. When no `<stash>` 146 is given, it removes the latest one. i.e. `stash@{0}`, otherwise 147 `<stash>` must be a valid stash log reference of the form 148 `stash@{<revision>}`. 149 150create:: 151 152 Create a stash (which is a regular commit object) and return its 153 object name, without storing it anywhere in the ref namespace. 154 This is intended to be useful for scripts. It is probably not 155 the command you want to use; see "save" above. 156 157 158DISCUSSION 159---------- 160 161A stash is represented as a commit whose tree records the state of the 162working directory, and its first parent is the commit at `HEAD` when 163the stash was created. The tree of the second parent records the 164state of the index when the stash is made, and it is made a child of 165the `HEAD` commit. The ancestry graph looks like this: 166 167 .----W 168 / / 169 -----H----I 170 171where `H` is the `HEAD` commit, `I` is a commit that records the state 172of the index, and `W` is a commit that records the state of the working 173tree. 174 175 176EXAMPLES 177-------- 178 179Pulling into a dirty tree:: 180 181When you are in the middle of something, you learn that there are 182upstream changes that are possibly relevant to what you are 183doing. When your local changes do not conflict with the changes in 184the upstream, a simple `git pull` will let you move forward. 185+ 186However, there are cases in which your local changes do conflict with 187the upstream changes, and `git pull` refuses to overwrite your 188changes. In such a case, you can stash your changes away, 189perform a pull, and then unstash, like this: 190+ 191---------------------------------------------------------------- 192$ git pull 193 ... 194file foobar not up to date, cannot merge. 195$ git stash 196$ git pull 197$ git stash pop 198---------------------------------------------------------------- 199 200Interrupted workflow:: 201 202When you are in the middle of something, your boss comes in and 203demands that you fix something immediately. Traditionally, you would 204make a commit to a temporary branch to store your changes away, and 205return to your original branch to make the emergency fix, like this: 206+ 207---------------------------------------------------------------- 208# ... hack hack hack ... 209$ git checkout -b my_wip 210$ git commit -a -m "WIP" 211$ git checkout master 212$ edit emergency fix 213$ git commit -a -m "Fix in a hurry" 214$ git checkout my_wip 215$ git reset --soft HEAD^ 216# ... continue hacking ... 217---------------------------------------------------------------- 218+ 219You can use 'git stash' to simplify the above, like this: 220+ 221---------------------------------------------------------------- 222# ... hack hack hack ... 223$ git stash 224$ edit emergency fix 225$ git commit -a -m "Fix in a hurry" 226$ git stash pop 227# ... continue hacking ... 228---------------------------------------------------------------- 229 230Testing partial commits:: 231 232You can use `git stash save --keep-index` when you want to make two or 233more commits out of the changes in the work tree, and you want to test 234each change before committing: 235+ 236---------------------------------------------------------------- 237# ... hack hack hack ... 238$ git add --patch foo # add just first part to the index 239$ git stash save --keep-index # save all other changes to the stash 240$ edit/build/test first part 241$ git commit -m 'First part' # commit fully tested change 242$ git stash pop # prepare to work on all other changes 243# ... repeat above five steps until one commit remains ... 244$ edit/build/test remaining parts 245$ git commit foo -m 'Remaining parts' 246---------------------------------------------------------------- 247 248Recovering stashes that were cleared/dropped erroneously:: 249 250If you mistakenly drop or clear stashes, they cannot be recovered 251through the normal safety mechanisms. However, you can try the 252following incantation to get a list of stashes that are still in your 253repository, but not reachable any more: 254+ 255---------------------------------------------------------------- 256git fsck --unreachable | 257grep commit | cut -d\ -f3 | 258xargs git log --merges --no-walk --grep=WIP 259---------------------------------------------------------------- 260 261 262SEE ALSO 263-------- 264linkgit:git-checkout[1], 265linkgit:git-commit[1], 266linkgit:git-reflog[1], 267linkgit:git-reset[1] 268 269GIT 270--- 271Part of the linkgit:git[1] suite