| git-diff(1) | |
| =========== | |
| NAME | |
| ---- | |
| git-diff - Show changes between commits, commit and working tree, etc | |
| SYNOPSIS | |
| -------- | |
| [synopsis] | |
| git diff [<options>] [<commit>] [--] [<path>...] | |
| git diff [<options>] --cached [--merge-base] [<commit>] [--] [<path>...] | |
| git diff [<options>] [--merge-base] <commit> [<commit>...] <commit> [--] [<path>...] | |
| git diff [<options>] <commit>...<commit> [--] [<path>...] | |
| git diff [<options>] <blob> <blob> | |
| git diff [<options>] --no-index [--] <path> <path> [<pathspec>...] | |
| DESCRIPTION | |
| ----------- | |
| Show changes between the working tree and the index or a tree, changes | |
| between the index and a tree, changes between two trees, changes resulting | |
| from a merge, changes between two blob objects, or changes between two | |
| files on disk. | |
| The <<EXAMPLES,EXAMPLES>> section has examples of the most common ways | |
| to diff. | |
| `git diff [<options>] [--] [<path>...]`:: | |
| This form is to view the changes you made relative to | |
| the index (staging area for the next commit). In other | |
| words, the differences are what you _could_ tell Git to | |
| further add to the index but you still haven't. You can | |
| stage these changes by using linkgit:git-add[1]. | |
| `git diff [<options>] --no-index [--] <path> <path> [<pathspec>...]`:: | |
| This form is to compare the given two paths on the | |
| filesystem. You can omit the `--no-index` option when | |
| running the command in a working tree controlled by Git and | |
| at least one of the paths points outside the working tree, | |
| or when running the command outside a working tree | |
| controlled by Git. This form implies `--exit-code`. If both | |
| paths point to directories, additional pathspecs may be | |
| provided. These will limit the files included in the | |
| difference. All such pathspecs must be relative as they | |
| apply to both sides of the diff. | |
| `git diff [<options>] --cached [--merge-base] [<commit>] [--] [<path>...]`:: | |
| This form is to view the changes you staged for the next | |
| commit relative to the named _<commit>_. Typically you | |
| would want comparison with the latest commit, so if you | |
| do not give _<commit>_, it defaults to `HEAD`. | |
| If `HEAD` does not exist (e.g. unborn branches) and | |
| _<commit>_ is not given, it shows all staged changes. | |
| `--staged` is a synonym of `--cached`. | |
| + | |
| If `--merge-base` is given, instead of using _<commit>_, use the merge base | |
| of _<commit>_ and `HEAD`. `git diff --cached --merge-base A` is equivalent to | |
| `git diff --cached $(git merge-base A HEAD)`. | |
| `git diff [<options>] [--merge-base] <commit> [--] [<path>...]`:: | |
| This form is to view the changes you have in your | |
| working tree relative to the named _<commit>_. You can | |
| use `HEAD` to compare it with the latest commit, or a | |
| branch name to compare with the tip of a different | |
| branch. | |
| + | |
| If `--merge-base` is given, instead of using _<commit>_, use the merge base | |
| of _<commit>_ and `HEAD`. `git diff --merge-base A` is equivalent to | |
| `git diff $(git merge-base A HEAD)`. | |
| `git diff [<options>] [--merge-base] <commit> <commit> [--] [<path>...]`:: | |
| This is to view the changes between two arbitrary | |
| _<commit>_. | |
| + | |
| If `--merge-base` is given, use the merge base of the two commits for the | |
| "before" side. `git diff --merge-base A B` is equivalent to | |
| `git diff $(git merge-base A B) B`. | |
| `git diff [<options>] <commit> <commit>...<commit> [--] [<path>...]`:: | |
| This form is to view the results of a merge commit. The first | |
| listed _<commit>_ must be the merge itself; the remaining two or | |
| more commits should be its parents. Convenient ways to produce | |
| the desired set of revisions are to use the suffixes `@` and | |
| `^!`. If `A` is a merge commit, then `git diff A A^@`, | |
| `git diff A^!` and `git show A` all give the same combined diff. | |
| `git diff [<options>] <commit>..<commit> [--] [<path>...]`:: | |
| This is synonymous to the earlier form (without the `..`) for | |
| viewing the changes between two arbitrary _<commit>_. If _<commit>_ on | |
| one side is omitted, it will have the same effect as | |
| using `HEAD` instead. | |
| `git diff [<options>] <commit>...<commit> [--] [<path>...]`:: | |
| This form is to view the changes on the branch containing | |
| and up to the second _<commit>_, starting at a common ancestor | |
| of both _<commit>_. `git diff A...B` is equivalent to | |
| `git diff $(git merge-base A B) B`. You can omit any one | |
| of _<commit>_, which has the same effect as using `HEAD` instead. | |
| Just in case you are doing something exotic, it should be | |
| noted that all of the _<commit>_ in the above description, except | |
| in the `--merge-base` case and in the last two forms that use `..` | |
| notations, can be any _<tree>_. A tree of interest is the one pointed to | |
| by the ref named `AUTO_MERGE`, which is written by the `ort` merge | |
| strategy upon hitting merge conflicts (see linkgit:git-merge[1]). | |
| Comparing the working tree with `AUTO_MERGE` shows changes you've made | |
| so far to resolve textual conflicts (see the examples below). | |
| For a more complete list of ways to spell _<commit>_, see | |
| "SPECIFYING REVISIONS" section in linkgit:gitrevisions[7]. | |
| However, `diff` is about comparing two _endpoints_, not ranges, | |
| and the range notations (`<commit>..<commit>` and `<commit>...<commit>`) | |
| do not mean a range as defined in the | |
| "SPECIFYING RANGES" section in linkgit:gitrevisions[7]. | |
| `git diff [<options>] <blob> <blob>`:: | |
| This form is to view the differences between the raw | |
| contents of two blob objects. | |
| OPTIONS | |
| ------- | |
| :git-diff: 1 | |
| include::diff-options.adoc[] | |
| `-1`:: | |
| `--base`:: | |
| `-2`:: | |
| `--ours`:: | |
| `-3`:: | |
| `--theirs`:: | |
| Compare the working tree with | |
| + | |
| -- | |
| * the "base" version (stage #1) when using `-1` or `--base`, | |
| * "our branch" (stage #2) when using `-2` or `--ours`, or | |
| * "their branch" (stage #3) when using `-3` or `--theirs`. | |
| -- | |
| + | |
| The index contains these stages only for unmerged entries i.e. | |
| while resolving conflicts. See linkgit:git-read-tree[1] | |
| section "3-Way Merge" for detailed information. | |
| `-0`:: | |
| Omit diff output for unmerged entries and just show | |
| "Unmerged". Can be used only when comparing the working tree | |
| with the index. | |
| `<path>...`:: | |
| The _<path>_ parameters, when given, are used to limit | |
| the diff to the named paths (you can give directory | |
| names and get diff for all files under them). | |
| include::diff-format.adoc[] | |
| [[EXAMPLES]] | |
| EXAMPLES | |
| -------- | |
| Diff uncommitted changes | |
| ~~~~~~~~~~~~~~~~~~~~~~~~ | |
| Show unstaged changes:: | |
| `git diff` | |
| Show staged changes:: | |
| `git diff --staged` or `git diff --cached` | |
| Show all changes since the latest commit:: | |
| `git diff HEAD` | |
| Show changes made to resolve a merge conflict:: | |
| `git diff AUTO_MERGE` | |
| Diff a specific file/directory | |
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| You can usually put a filename or directory at the end to restrict the | |
| diff to that file/directory. You don't always need to put a `--`, but it | |
| makes it unambiguous. | |
| Show how `file.txt` has changed since `main`:: | |
| `git diff main -- file.txt` | |
| Show unstaged changes for `file.txt`:: | |
| `git diff -- file.txt` | |
| Show unstaged changes in `dir/`:: | |
| `git diff -- ./dir` | |
| Diff branches or commits | |
| ~~~~~~~~~~~~~~~~~~~~~~~~ | |
| Show changes on the `topic` branch since it branched off `main`:: | |
| `git diff --merge-base main topic` | |
| Show changes between the `topic` branch and the `main` branch:: | |
| `git diff main topic` | |
| Show changes between commit `ff11cc` and `HEAD`:: | |
| `git diff ff11cc HEAD` | |
| Options to summarize the output | |
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| Show how many lines in each file were changed:: | |
| `git diff` <<stat,`--stat`>> | |
| Only show names of changed files:: | |
| `git diff` <<name_only,`--name-only`>> | |
| Only show filenames and whether they were modified/deleted/added:: | |
| `git diff` <<name_status,`--name-status`>> | |
| Options to display the diff in another way | |
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| Ignore all whitespace changes:: | |
| `git diff` <<ignore_all_space,`--ignore-all-space`>> | |
| Show which individual words changed instead of the whole line:: | |
| `git diff` <<word_diff,`--word-diff`>> | |
| CONFIGURATION | |
| ------------- | |
| include::includes/cmd-config-section-all.adoc[] | |
| :git-diff: 1 | |
| include::config/diff.adoc[] | |
| SEE ALSO | |
| -------- | |
| `diff`(1), | |
| linkgit:git-difftool[1], | |
| linkgit:git-log[1], | |
| linkgit:gitdiffcore[7], | |
| linkgit:git-format-patch[1], | |
| linkgit:git-apply[1], | |
| linkgit:git-show[1] | |
| GIT | |
| --- | |
| Part of the linkgit:git[1] suite |