git-clean - Remove untracked files from the working tree

Synopsis

git clean [-d] [-f] [-i] [-n] [-q] [-e <pattern>] [-x | -X] [--] <path>…​

Description

Cleans the working tree by recursively removing files that are not under version control, starting from the current directory.

Normally, only files unknown to Git are removed, but if the -x option is specified, ignored files are also removed. This can, for example, be useful to remove all build products.

If any optional <path>... arguments are given, only those paths are affected.

Step 1 is to show what will be deleted by using the -n option:

# Print out the list of files and directories which will be removed (dry run)
git clean -n -d

Clean Step - beware: this will delete files:

# Delete the files from the repository
git clean -f

• To remove directories, run git clean -f -d or git clean -fd
• To remove ignored files, run git clean -f -X or git clean -fX
• To remove ignored and non-ignored files, run git clean -f -x or git clean -fx

Note the case difference on the X for the two latter commands.

If clean.requireForce is set to "true" (the default) in your configuration, one needs to specify -f otherwise nothing will actually happen.

Again see the git-clean docs for more information.

Options

-f, --force

If the Git configuration variable clean.requireForce is not set to false, git clean will refuse to run unless given -f, -n or -i.

-x

Don’t use the standard ignore rules read from .gitignore (per directory) and $GIT_DIR/info/exclude, but do still use the ignore rules given with -e options. This allows removing all untracked files, including build products. This can be used (possibly in conjunction with git reset) to create a pristine working directory to test a clean build.

-X

Remove only files ignored by Git. This may be useful to rebuild everything from scratch, but keep manually created files.

-n, --dry-run

Don’t actually remove anything, just show what would be done.

-d

Remove untracked directories in addition to untracked files. If an untracked directory is managed by a different Git repository, it is not removed by default. Use -f option twice if you really want to remove such a directory.

If I understand your question correctly, you want to reset all files that are currently tracked to the previous commit and leave the untracked files alone.

If so, then I would do as follows.

First way

As mentioned by Porges in the comments.

First unstage all your currently modified files:

git reset

Then reset all unstaged modified files to the previous commit.

git checkout -- .

Second way (Git 1.7.7+ only)

First I would stash the tracked files as follows:

git stash

Then I would stash the untracked files as follows:

git stash -u

Hence, now you have two stashes on your stack: one with tracked files on the bottom and one with untracked files on the top. Pop off the tracked files as follows (aka apply the stash that is second in the stack):

git stash apply stash@{1}

Then reset to the previous commit:

git reset --hard

Finally, apply the untracked files:

git stash apply

git stash internally creates special black magic merge commits to store different parts of your changes. The merge commit has the original base commit (what you had at the top of the branch when you stashed) as its first parent, a throwaway commit representing the index contents at time of stashing as its second parent, and (only if you used --include-untracked) a throwaway commit containing the untracked files as its third parent.

So, the merge commit references the untracked files (as one of its parents)... but it doesn't actually include those files in its own tree (if that doesn't make any sense, either you've got a few things to learn yet about Git's internals... or you know too much about merge commits and this whole construct just seems too horrible to think about ;)).

In short... to access the untracked parts of your stash, access its third parent: git checkout stash@{0}^3 -- filename

git checkout doesn't overwrite your working copy by-design.

It works in the same way as git reset --hard but with the important difference - git checkout is working-directory safe, so it doesn't overwrite existing changes in your working directory. Actually, it’s a bit smarter — it tries to do a trivial merge in the working directory.

So, if you want to discard all of your changes and just get the snapshot from HEAD use git reset --hard HEAD or just git reset --hard instead.

But even git reset --hard doesn't remove your untracked files. To remove untracked files:

• Run git clean --dry-run. It just tells you what will be removed. Do it because cleaning is a dangerous command.
• Run git clean --force to eventually remove your untracked files.

You can find more details about git checkout and git reset here and about cleaning here.

When you switch to a branch, Git makes sure that your working tree matches the content of the commit you're switching. Quoting an extract of Basic Branching of the Git Pro book:

when you switch branches, Git resets your working directory to look like it did the last time you committed on that branch. It adds, removes, and modifies files automatically to make sure your working copy is what the branch looked like on your last commit to it.

This means that:

• Every tracked file in your working directory that is not present in the selected commit will be removed.

• Every tracked file in the selected commit that is not present in your working directory will be added.

• Every tracked file that is present in both your working directory and the selected commit will be updated to the version contained in the commit.

In your case, even though master had a .gitignore for some of the files on gitignoreless, once you switched to master those files had to be removed in order to match the content of master's head commit. This is because the files were already tracked on gitignoreless, and every tracked file in the working directory that is not contained in the selected commit is removed.

As already explained by @matt, .gitignore affects only files that are not already in the index. Therefore, you might want to consider having your .gitignore on all your branches, and build it in such a way to not show undesired files during the staging process. However, since some of the undesired files have already been tracked, you can "untrack" them with the --cached option of git rm. In your case, you could run:

# untrack the undesired files
git rm --cached <file1> <file2> ... <fileN>

# add the previous files as entries in your gitignore
echo <file1> >> .gitgnore
echo <file2> >> .gitgnore
...
echo <fileN> >> .gitgnore