[jeroen]

> Files in Git can be in one of these three states: Modified, Staged, Committed

> Staged: The current version of the modified file is staged to be included in the next commit.

A bit of a nitpick, but if I change a file, "git add" it, and then change it again, both of these statements are false.

[jjmarr]

I use git add -p somewhat frequently to do partial staging of a file to split up my changes into multiple commits.

[sham1]

`git add -p` is such a nice utility. Sometimes I do wish that it could also be used for unstages files, so that if I'm introducing a new file, I could still break its contents up into multiple commits.

Of course, the workaround there is that one adds the initial file into the staging area and then `git add -p` the subsequent changes. It could just be a bit more convenient on that front, is all.

[matheusmoreira]

It can, you just gotta do a magic incantation first.

  git add -N file
  git add -p file

The first command signals to git that you intend to add the file. That makes its entire content show up in the patch editor.

[sham1]

TIL! I seem to have just missed the `-N`/`--intend-to-add` while perusing through the `git-add(1)` manual.

Heh, it[0] even notes a similar use case:

> `-N` > `--intent-to-add` > > Record only the fact that the path will be added later. An entry for the path is placed in the index with no content. This is useful for, among other things, showing the unstaged content of such files with `git diff` and committing them with `git commit -a`.

[0]: <https://git-scm.com/docs/git-add#Documentation/git-add.txt--...>

[tczMUFlmoNk]

Alternately:

    git add file
    git reset -p file

[johnisgood]

Wow, I have been using git for ages but I did not know about this. I was relying on magit (for Emacs) and git-cola.

[masklinn]

Magit does interactive staging (and unstaging) a lot better than git itself does.

In d u, you can “s” on a file or hunk and it’ll stage just that. And if you select lines (c-spc?) it’ll stage just those lines.

To unstage, go to d s and use “u” the same way.

The massive advantage aside from line-wise staging is that you don’t need to stage linearly.

[ht85]

You can also discard changes that way, e.g.:

    git checkout -p -- .

[johnisgood]

I will have to read about how to use it, because it shows some hunks on a page, and I do not want to stage all of them, for example.

[jeroen]

When it shows you a hunk that's bigger than you like, you can use 's' to split it into smaller hunks.

[johnisgood]

Thank you!

[gurjeet]

I think if the word "Files" was replaced with "A change [in a file]", then the statement holds true. Perhaps a better phrasing:

> In Git, a change in a file, can be in one of these three states: unstaged, Staged, Committed