6 git-commit - Record your changes
11 'git-commit' [-a] [-s] [-v] [(-c | -C) <commit> | -F <file> | -m <msg>]
12 [--no-verify] [--amend] [-e] [--author <author>]
13 [--] [[-i | -o ]<file>...]
17 Use 'git commit' when you want to record your changes into the repository
18 along with a log message describing what the commit is about. All changes
19 to be committed must be explicitly identified using one of the following
22 1. by using gitlink:git-add[1] to incrementally "add" changes to the
23 next commit before using the 'commit' command (Note: even modified
24 files must be "added");
26 2. by using gitlink:git-rm[1] to identify content removal for the next
27 commit, again before using the 'commit' command;
29 3. by directly listing files containing changes to be committed as arguments
30 to the 'commit' command, in which cases only those files alone will be
31 considered for the commit;
33 4. by using the -a switch with the 'commit' command to automatically "add"
34 changes from all known files i.e. files that have already been committed
35 before, and perform the actual commit.
37 The gitlink:git-status[1] command can be used to obtain a
38 summary of what is included by any of the above for the next
39 commit by giving the same set of parameters you would give to
42 If you make a commit and then found a mistake immediately after
43 that, you can recover from it with gitlink:git-reset[1].
49 Tell the command to automatically stage files that have
50 been modified and deleted, but new files you have not
51 told git about are not affected.
54 Take existing commit object, and reuse the log message
55 and the authorship information (including the timestamp)
56 when creating the commit. With '-C', the editor is not
57 invoked; with '-c' the user can further edit the commit
61 Take the commit message from the given file. Use '-' to
62 read the message from the standard input.
65 Override the author name used in the commit. Use
66 `A U Thor <author@example.com>` format.
69 Use the given <msg> as the commit message.
72 Add Signed-off-by line at the end of the commit message.
75 By default, the command looks for suspicious lines the
76 commit introduces, and aborts committing if there is one.
77 The definition of 'suspicious lines' is currently the
78 lines that has trailing whitespaces, and the lines whose
79 indentation has a SP character immediately followed by a
80 TAB character. This option turns off the check.
83 The message taken from file with `-F`, command line with
84 `-m`, and from file with `-C` are usually used as the
85 commit log message unmodified. This option lets you
86 further edit the message taken from these sources.
90 Used to amend the tip of the current branch. Prepare the tree
91 object you would want to replace the latest commit as usual
92 (this includes the usual -i/-o and explicit paths), and the
93 commit log editor is seeded with the commit message from the
94 tip of the current branch. The commit you create replaces the
95 current tip -- if it was a merge, it will have the parents of
96 the current tip as parents -- so the current top commit is
100 It is a rough equivalent for:
102 $ git reset --soft HEAD^
103 $ ... do something else to come up with the right tree ...
104 $ git commit -c ORIG_HEAD
107 but can be used to amend a merge commit.
111 Before making a commit out of staged contents so far,
112 stage the contents of paths given on the command line
113 as well. This is usually not what you want unless you
114 are concluding a conflicted merge.
117 Supress commit summary message.
120 Do not interpret any more arguments as options.
123 When files are given on the command line, the command
124 commits the contents of the named files, without
125 recording the changes already staged. The contents of
126 these files are also staged for the next commit on top
127 of what have been staged before.
132 When recording your own work, the contents of modified files in
133 your working tree are temporarily stored to a staging area
134 called the "index" with gitlink:git-add[1]. Removal
135 of a file is staged with gitlink:git-rm[1]. After building the
136 state to be committed incrementally with these commands, `git
137 commit` (without any pathname parameter) is used to record what
138 has been staged so far. This is the most basic form of the
149 We should fix 'git rm' to remove goodbye.c from both index and
150 working tree for the above example.
153 Instead of staging files after each individual change, you can
154 tell `git commit` to notice the changes to the files whose
155 contents are tracked in
156 your working tree and do corresponding `git add` and `git rm`
157 for you. That is, this example does the same as the earlier
158 example if there is no other change in your working tree:
166 The command `git commit -a` first looks at your working tree,
167 notices that you have modified hello.c and removed goodbye.c,
168 and performs necessary `git add` and `git rm` for you.
170 After staging changes to many files, you can alter the order the
171 changes are recorded in, by giving pathnames to `git commit`.
172 When pathnames are given, the command makes a commit that
173 only records the changes made to the named paths:
176 $ edit hello.c hello.h
177 $ git add hello.c hello.h
179 $ git commit Makefile
182 This makes a commit that records the modification to `Makefile`.
183 The changes staged for `hello.c` and `hello.h` are not included
184 in the resulting commit. However, their changes are not lost --
185 they are still staged and merely held back. After the above
192 this second commit would record the changes to `hello.c` and
193 `hello.h` as expected.
195 After a merge (initiated by either gitlink:git-merge[1] or
196 gitlink:git-pull[1]) stops because of conflicts, cleanly merged
197 paths are already staged to be committed for you, and paths that
198 conflicted are left in unmerged state. You would have to first
199 check which paths are conflicting with gitlink:git-status[1]
200 and after fixing them manually in your working tree, you would
201 stage the result as usual with gitlink:git-add[1]:
204 $ git status | grep unmerged
210 After resolving conflicts and staging the result, `git ls-files -u`
211 would stop mentioning the conflicted path. When you are done,
212 run `git commit` to finally record the merge:
218 As with the case to record your own changes, you can use `-a`
219 option to save typing. One difference is that during a merge
220 resolution, you cannot use `git commit` with pathnames to
221 alter the order the changes are committed, because the merge
222 should be recorded as a single commit. In fact, the command
223 refuses to run when given pathnames (but see `-i` option).
231 ENVIRONMENT VARIABLES
232 ---------------------
233 The command specified by either the VISUAL or EDITOR environment
234 variables is used to edit the commit log message.
238 This command can run `commit-msg`, `pre-commit`, and
239 `post-commit` hooks. See link:hooks.html[hooks] for more
248 gitlink:git-merge[1],
249 gitlink:git-commit-tree[1]
253 Written by Linus Torvalds <torvalds@osdl.org> and
254 Junio C Hamano <junkio@cox.net>
259 Part of the gitlink:git[7] suite
projects / git / blob