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