How to remove local (untracked) files from the current Git working tree?

How do you delete untracked local files from your current working tree?

  • JGit : How to get Branch when traversing repos
  • Using GIT with GIT GUI - Master and Branching
  • Git - push to a remote-tracking branch in the remote repository
  • TFS 2010: How to produce a changelog (ie. list of work items) between two releases of the application using labels?
  • What is the standard or best way to deal with database branching with Mercurial or Git branches?
  • Pushing one git branch requires a pull on another?
  • Git rebase my forked branch on upstream master
  • git status shows “\n\n” as an untracked file
  • Extract changes from diff file to current branch
  • Undo git stash pop that results in merge conflict
  • Global gitignore of files with tilde “~” (at the end of file name)
  • what are “automerged” files in git, and how do you list them all?
  • 28 Solutions collect form web for “How to remove local (untracked) files from the current Git working tree?”

    As per the Git Documentation git clean

    Remove untracked files from the working tree


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

    git clean -n
    

    Clean Step – beware: this will delete files:

    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.

    Use git clean -f -d to make sure that directories are also removed.

    You can then check if your files are really gone with git status.

    git-clean – Remove untracked files from the working tree

    I am surprised nobody mentioned this before:

    git clean -i
    

    That stands for interactive and you will get a quick overview of what is going to be deleted offering you the possibility to include/exclude the affected files. Overall, still faster than running the mandatory --dry-run before the real cleaning.

    You will have to toss in a -d if you also want to take care of empty folders. At the end, it makes for a nice alias:

    git iclean
    

    That being said, the extra hand holding of interactive commands can be tiring for experienced users. These days I just use the already mentioned git clean -fd

    If untracked directory is a git repository of its own (e.g. submodule), you need to use -f twice:

    git clean -d -f -f

    I like git stash save -u because you can undo them all with git stash pop.

    EDIT: Also I found a way to show untracked file in a stash (e.g. git show stash@{0}^3) https://stackoverflow.com/a/12681856/338986

    Simple Way to remove untracked files

    To remove all untracked files, The simple
    way is to add all of them first and reset the repo as below

    git add --all
    git reset --hard HEAD
    

    git-clean is what you are looking for. It is used to remove untracked files from the working tree.

    This is what I always use:

    git clean -fdx
    

    For a very large project you might want to run it a couple of times.

    If needed to remove untracked files from particular subdirectory,

    git clean -f {dir_path}
    

    And combined way to delete untracked dir/files and ignored files.

    git clean -fxd {dir_path}
    

    after this you will have modified files only in git status.

    git clean -fd removes directory

    git clean -fX removes ignored files

    git clean -fx removes ignored and un-ignored files

    can be used all above options in combination as

    git clean -fdXx

    check git manual for more help

    A better way is to use: git clean

    git clean -d -x -f
    

    This removes untracked files, including directories (-d) and files ignored by git (-x).

    Also, replace the -f argument with -n to perform a dry-run or -i for interactive mode and it will tell you what will be removed.

    User interactive approach:

    git clean -i -fd
    
    Remove .classpath [y/N]? N
    Remove .gitignore [y/N]? N
    Remove .project [y/N]? N
    Remove .settings/ [y/N]? N
    Remove src/com/arsdumpgenerator/inspector/ [y/N]? y
    Remove src/com/arsdumpgenerator/manifest/ [y/N]? y
    Remove src/com/arsdumpgenerator/s3/ [y/N]? y
    Remove tst/com/arsdumpgenerator/manifest/ [y/N]? y
    Remove tst/com/arsdumpgenerator/s3/ [y/N]? y
    

    -i for interactive
    -f for force
    -d for directory
    -x for ignored files(add if required)

    Note: Add -n or –dry-run to just check what it will do.

    git clean -f -d -x $(git rev-parse --show-cdup) applies clean to the root directory, no matter where you call it within a repository directory tree. I use it all the time as it does not force you to leave the folder where you working now and allows to clean & commit right from the place where you are.

    Be sure that flags -f, -d, -x match your needs:

    -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.
    
    -f, --force
           If the Git configuration variable clean.requireForce is not set to
           false, git clean will refuse to delete files or directories unless
           given -f, -n or -i. Git will refuse to delete directories with .git
           sub directory or file unless a second -f is given. This affects
           also git submodules where the storage area of the removed submodule
           under .git/modules/ is not removed until -f is given twice.
    
    -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.
    

    There are other flags as well available, just check git clean --help.

    A lifehack for such situation I just invented and tried (that works perfectly):

    git add .
    git reset --hard HEAD
    

    Beware! Be sure to commit any needed changes (even in non-untracked files) before performing this.

    If you just want to delete the files listed as untracked by ‘git status’

    git stash save -u
    git stash drop "stash@{0}"
    

    I prefer this to ‘git clean’ because ‘git clean’ will delete files
    ignored by git, so your next build will have to rebuild everything
    and you may lose your IDE settings too.

    To remove everything: Get repo in same state as if fresh clone

    git clean -fdx
    

    To remove extraneous folders such as build outputs

    git clean -fd
    

    To remove extraneous folders + files such as build + IDE temp files

    This removes only ignored filed. If file wasn’t ignored + not checked-in then it stays.

    git clean -fdX
    

    New interactive mode

    git clean
    

    To know what will be deleted before actually deleting:

    git clean -d -n

    It will output something like:

    Would remove sample.txt

    To delete everything listed in the output of the previous command:

    git clean -d -f

    It will output something like:

    Removing sample.txt

    Someone should really mention:

    git clean [<options>]
    

    Am I right?

    For me only following worked:

    git clean -ffdx
    

    In all other cases, I was getting message “Skipping Directory” for some subdirectories.

    To remove the untracked files you should first use command to view the files that will be affected by cleaning

    git clean -fdn
    

    This will show you the list of files that will be deleted. Now to actually delete those files use this command:

    git clean -fd
    

    OK, deleting unwanted untracked files and folders are easy using git in command line, just do:

    git clean -fd
    

    Double check before doing it as it will delete the files and folders without making any history…

    Also in this case, -f stands for force and -d stands for directory…

    So, if you want to delete files only, you can use -f only:

    git clean -f
    

    If you want to delete(directories) and files, you can delete only untracked directories and files like this:

    git clean -fd
    

    Also, you can use -x flag for including the files which are ignored by git. This would be helpful if you want to delete everything.

    And adding -i flag, makes git asking you for permission for deleting files one by one on the go.

    If you not sure and want to check things first, add -n flag.

    Use -q if you don’t want to see any report after successful deletion.

    I also create the image below to make it more memorisable, specially I have seen many people confuse -f for cleaning folder sometimes or mix it up somehow!

    deleting unwanted untracked files and folder

    Normal git clean command doesn’t remove untracked files with my git version 2.9.0.windows.1.

    $ git clean -fdx     # doesn't remove untracked files
    $ git clean -fdx *   # Append star then it works!
    

    git clean -f to remove untracked files from working directory.

    I have covered some basics here in my blog, git-intro-basic-commands

    Note: First navigate to the directory and checkout the branch you want to clean.

    -i interactive mode and it will tell you what will be removed and you can choose an action from the list.

    1. To clean files only [Folders will not be listed and will not be cleaned]:
      $ git clean -i

    2. To clean files and folders:
      $ git clean -d -i

    -d including directories.


    If you choose c from the list. The files/folders will be deleted that are not tracked and will also remove files/folders that you mess-up.*

    For instance: If you restructure the folder in your remote and pull the changes to your local computer. files/folders that are created by others initially will be in past folder and in the new one that you restructure.

    use git reset HEAD <file> to unstage a file

    uggested Command for Removing Untracked Files from git docs is git clean

    git clean – Remove untracked files from the working tree

    Suggested Method: Interative Mode by using git clean -i
    so we can have control over it. let see remaining available options.

    Available Options:

    git clean 
        -d -f -i -n -q -e -x -X (can use either)
    

    Explanation:

    1. -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.

    2. -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.

    3. -i, –interactive

    Show what would be done and clean files interactively. See “Interactive mode” for details.

    4. -n, –dry-run

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

    5. -q, –quiet

    Be quiet, only report errors, but not the files that are successfully removed.

    6. -e , –exclude=

    In addition to those found in .gitignore (per directory) and $GIT_DIR/info/exclude, also consider these patterns to be in the
    set of the ignore rules in effect.

    7. -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.

    8. -X

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

    You can also just use rm: rm -rf filename

    Git Baby is a git and github fan, let's start git clone.