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

Created 14.09.2008 09:06
Viewed 2.47M times
7251 votes

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

8
Comments
This interactive git cheat sheet ndpsoftware.com/git-cheatsheet.html shows the git workspace (google gives you better results with "workspace" than "working copy"). by qneill, 01.02.2013 15:43
Note: if you only want to remove some untracked files, but not all of them, git clean has now an interactive mode! See my answer to this other question: git 1.8.4+ by VonC, 23.07.2013 06:00
Note that you're not removing files from git branch, as branch is a reference to a commit and therefore doesn't contain untracked files. Those are only present in the working directory and have nothing to do with branches. That's probably just terminology clarification. by Pavel Šimerda, 14.09.2014 22:28
Before you post a new answer, consider there are already 25+ answers for this question. Make sure that your answer contributes what is not among existing answers by Sazzad Hissain Khan, 15.06.2017 15:30
To clarify for the understanding of the uninitiated and those new to Git - run git status and if it shows a file as untracked, and you don't want that file in the repo, you can just go to your filesystem and delete or move it. This will not do anything bad to your local repo or to Git. You can also use git clean or some variation in the answers below, including the interactive version to delete just selective files, but interactive mode can be tedious. Whatever you do, make sure you understand what git clean will delete or use --dry-run to have it tell you without deleting anything. by LightCC, 02.09.2017 06:15
If the files are not yet being tracked, couldn't you just remove them without git? rm files-to-be-deleted by mhatch, 14.03.2018 20:48
I would Stash it in case you need to use them again and to clean use git clean: more deatils: git-scm.com/docs/git-clean by Cafebabe, 20.06.2018 20:44
@User1291 you will loose all your local branches and stashes if you fresh clone in another directory. by Abdul Rauf, 13.07.2018 05:20
Show remaining 3 comments
Answers 40
17
9089

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.

15.09.2008 17:32
Comments
git clean -f works only in the directory where it's called (and subdirectories). If you want to clean the whole working copy, you should call it in its root directory. by Eduardo Bezerra, 08.03.2013 10:51
How do I make it include ignored directories/files? by Jürgen Paul, 14.05.2013 12:39
It is also removing all files inside .gitignore. I need to delete only files/folders which are new and not in .gitignore by Kostanos, 05.08.2013 23:02
@Kostanos If you don't want to remove files that are in .gitignore, then do not provide the -x flag. by Lo-Tan, 23.08.2013 18:44
Note that -x or -X flags remove the files ignored by .gitignore, but not those ignored by update-index --assume-unchanged. by Ville, 05.11.2013 22:52
I am sorry if I am missing anything, but is git clean -f different from simply deleting the file ? by maan81, 30.09.2014 09:49
git clean -f :/ works as if you had run it in the root repo dir. See also later answers also accounting for submodules with git clean -ffxd :/ by here, 16.10.2014 20:38
The number of votes says how important it is to have a command that is more intuitive. Something like git remove untracked or git remove_untracked by Ich, 07.05.2015 20:26
@Michelle git clean -xfd WILL also REMOVE ALL FILES CURRENTLY IGNORED IN YOUR .gitignore and they are not recoverable by thedanotto, 20.11.2015 05:36
@Michelle : Nice to write, what actually it does, it deletes all files which has been in gitignore list and I came to know about this thing after bad experience. by Akash KC, 05.06.2016 12:52
@maan81, you're right. git clean -f is no different from simply deleting a file. But that doesn't make it useless as I, maybe incorrectly, feel you implied. When you have a lot of build artifacts, that is hundreds of files in tens of directories, "simply deleting" them may turn out to be not that "simple". You will have to script it. That's what git clean -f does for you as it knows exactly which files do and which don't belong to the repo. by Alexander Amelkin, 03.07.2017 10:24
Use -f option twice if you really want to remove such a directory. that's what I was after! thanks! by Kevin Friedheim, 17.07.2017 18:14
After struggling and cursing for 45 solid minutes, I found @EduardoBezerra's comment... I think the OP should edit his answer to emphasize git clean's behavior - of only deleting stuff in the directory you are - and subdirectories thereof. It's not clear from git help or from the answer itself. by Motti Shneor, 20.09.2018 15:43
use -i for making it interactive by Bharat, 02.08.2019 09:40
git clean -fd was the magical part of your answer I needed to remove all untracked files and directories! by Gabriel Staples, 18.03.2020 00:27
Note that git clean works on a directory level, not a repo level. So if you run git clean inside a directory in the repo, it only cleans recursively in the directory. by zed, 14.05.2020 14:59
Or easily use git add -A && git reset --hard by Omid Ostovari, 22.04.2021 06:44
Show remaining 12 comments
2
1084

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

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

    git clean -n
    

    or

    git clean --dry-run
    
  2. 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 the -f option twice if you really want to remove such a directory.

    git clean -fd
    

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

26.05.2009 20:59
Comments
As previously stated, good to dry-run it with git clean -n -d by Ms01, 09.12.2013 10:54
Same thing is to do git clean -nd and git clean -fd. by Micer, 10.07.2017 09:13
3
513

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

30.12.2013 20:12
Comments
@pal4life It was added in 1.8.4, you might be running an older version of git? github.com/git/git/blob/master/Documentation/RelNotes/1.8.4.‌​txt by Mattias Backman, 30.09.2014 12:37
I like this – I'm more comfortable having it in my bash history than any of the other options, because it's no big deal if I accidentally ctrl-r or ctrl-p to it. by csvoss, 21.10.2019 22:38
Could it be that git clean -i works only if called from the root of the working copy? by Alessandro Jacopson, 04.06.2020 10:43
Comments
git clean -f 'untracked file path' by Hossain Mahmood Tuhin, 29.04.2021 09:24
11
291

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

03.06.2016 12:16
Comments
You can replace git add --all by git add .. So you can do it in a shorter way in oneline git add . && git reset --hard HEAD ( be very carefull with this command). by RousseauAlexandre, 30.03.2017 13:35
Why use this over git clean? by user2864740, 30.06.2017 21:59
Because git clean apparently also deletes everything that is ignored. It just deleted my node_modules folder. Doing this would first stage all files except for the ignored ones, and then delete them by doing a reset. Ignored files will not be touched. by Andreas, 19.09.2017 07:54
@Andreas it doesn't delete ignored files for me (git 2.14.1). You should run git clean -n anyway before doing the real deletion (or use git clean -i). by Qw3ry, 26.09.2017 11:12
@Qw3ry git version 2.10.2.windows.1 over here, strange. by Andreas, 26.09.2017 13:52
git clean deletes ignored files only if you use either the -x or -X option, otherwise it just deletes untracked files. by doubleDown, 26.09.2017 20:17
@user2864740 If I am getting it right, this option will not only removed untracked files but users will also lose any changes they made in tracked files. For those it worked, they may be looking to reset those changes apart from deleting untracked files, though that is not the question here. by Varun Garg, 20.12.2017 17:15
@RousseauAlexandre git add . only adds from the current directory on down, whereas git add --all applies to the repo. The latter appears like a safer option. by TrueWill, 16.01.2018 19:09
You should commit any changes you want to keep before running this as it will delete them. by Pants, 09.04.2018 15:20
Awesome... I already ran the solution for my commit from stackoverflow.com/questions/927358/… and this was all I needed. by Cody, 18.09.2019 16:38
Is it necessary to specify HEAD here ? I tried without and it worked. by Tore Aurstad, 04.08.2020 16:06
Show remaining 6 comments
2
272

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

git clean -d -f -f

25.01.2013 12:24
Comments
BTW, this is written in documentation : Git will refuse to delete directories with .git sub directory or file unless a second -f is given. But thanks anyway! by Maxim Suslov, 24.07.2015 09:03
Thank you tons. This was driving me nuts. by m4heshd, 02.02.2021 01:19
4
148

I like git stash push -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

EDIT2: git stash save is deprecated in favor of push. Thanks @script-wolf.

11.01.2014 00:41
Comments
Can you explain the -u on the stash? I do not follow how that works differently from git stash save. I tried this and it worked. Looked on git docs and could not find it there either. by Winnemucca, 17.10.2016 20:52
-u is equivalent to --include-untracked. You can find a help with git help stash. by hiroshi, 18.10.2016 08:55
@hiroshi Thanks! after trying every darn solution from a dozen different people this is the one that finally worked...whew ! Even a git stash did nada. The save - u took care of untracked. reset hard /clean force/etc none of these did anything for me. by killjoy, 15.02.2017 16:26
The save option was deprecated in favor of push, which does the same but more. You can read more here, https://stackoverflow.com/questions/44680028/whats-the-diffe‌​rence-between-git-st‌​ash-save-and-git-sta‌​sh-push/44681952 by Script Wolf, 24.10.2018 15:51
2
132

This is what I always use:

git clean -fdx

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

25.11.2013 14:16
Comments
@Martin One of the projects I'm working on is +8 years old with +80 developers actively coding. Git sometimes fails to clean it on the first pass. by Oscar Fraxedas, 29.02.2016 13:10
I can confirm this, so this is still valid in 2020. We are also working on a large project and I had to run it 4-5 times until GIT did not find any more files to be deleted. by turbolocust, 17.04.2020 06:37
0
96

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

14.09.2008 09:08
0
90

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.

24.09.2013 06:28
0
79

Remove all extra folders and files in this repo + submodules

This gets you in same state as fresh clone.

git clean -ffdx

Remove all extra folders and files in this repo but not its submodules

git clean -fdx

Remove extra folders but not files (ex. build or logs folder)

git clean -fd

Remove extra folders + ignored files (but not newly added files)

If file wasn't ignored and not yet checked-in then it stays. Note the capital X.

git clean -fdX

New interactive mode

git clean
12.02.2017 08:33
2
62

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

22.01.2015 06:33
Comments
The command git clean -fdXx produces the error message "fatal: -x and -X cannot be used together" (using git-2.8). For your last sentence within your answer, please provide a link to git manual. Cheers by oHo, 04.07.2016 16:23
run the two commands in sequence: git clean -fdX, git clean -fdx by Clock ZHONG, 17.12.2018 05:19
2
61

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

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 memorable, especially I have seen many people confuse -f for cleaning folder sometimes or mix it up somehow!


deleting unwanted untracked files and folder

20.07.2017 16:42
Comments
What's with that image? by Pacerier, 30.01.2020 15:27
+ for easy to memorize graphic :D by EKOlog, 02.04.2021 11:49
0
39

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.

16.04.2015 06:49
0
28

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.

02.03.2017 20:09
5
22

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.

21.02.2016 17:29
Comments
At least this is a different approach. :) Another way, that would remember the deleted files in the reflog but not in any branches, would be: git add . git commit -m 'about to delete' git reset --hard HEAD~ by joeytwiddle, 01.03.2016 06:10
even more quick way is git add . && git reset --hard HEAD by thybzi, 29.04.2016 18:25
git add . && git reset --hard by Pleymor, 19.07.2016 11:35
This might not be what you want if there are also changes you do wish to commit. by lacostenycoder, 10.02.2017 20:00
@AlexanderMills git reset --hard resets all uncommited changes BUT UNTRACKED FILES to the state of the latest commit. That is why we first need git add . -- that stages all untracked files (so they are reset, too) by thybzi, 30.08.2017 11:54
1
21

For me only following worked:

git clean -ffdx

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

16.08.2016 15:29
Comments
Thanks. I left out the -x and just used git clean -ffd to avoid erasing files in the .gitignore. by Feckmore, 25.01.2017 17:46
1
20

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.

02.12.2015 17:57
Comments
BTW you can just do git clean {flags} :/ so it will be as if you ran the command in the repo root by The-null-Pointer-, 24.06.2017 19:07
2
17

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.

02.03.2016 02:09
Comments
This will also remove valid changes to tracked files. I wouldn't recommend it. by code_dredd, 04.04.2016 17:06
Yeah, you'd want to commit changes to tracked files first. by JD Brennan, 05.04.2016 00:01
0
16

To remove Untracked files :

git add .
git reset --hard HEAD
20.05.2020 16:05
0
15

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

16.02.2016 08:42
0
12

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
25.10.2016 09:09
1
12

Be careful while running `git clean` command.

Always use -n before running the actual command as it will show you what files would get removed.

git clean -n -d 
git clean -f -d

By default, git clean will only remove untracked files that are not ignored. Any file that matches a pattern in your .gitignore or other ignore files will not be removed. If you want to remove those files too, you can add a -x to the clean command.

git clean -f -d -x

There is also interactive mode available -i with the clean command

git clean -x -i

Alternatively

If you are not 100% sure that deleting your uncommitted work is safe, you could use stashing instead

git stash --all

It will also clear your directory but give you flexibility to retrieve the files at any point in time using stash with apply or pop. Then at later point you could clear your stash using:

git stash drop // or clean
21.10.2017 21:44
Comments
the stash is a good idea, however you might wanna use git stash save and type some comment as to what this stash was for by lacostenycoder, 30.06.2019 15:46
0
9

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!
11.10.2016 00:14
1
10

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.

01.09.2017 06:23
Comments
I think you have a typo uggested but that's just a "uggestion lol by lacostenycoder, 30.06.2019 15:44
0
9

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

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

16.02.2017 09:05
1
7

Clean out git repository and all submodules recursively

The following command will clean out the current git repository and all its submodules recursively:

(git clean -d -x -f && git submodule foreach --recursive git clean -d -x -f)
25.09.2017 16:25
Comments
surely this should be used with great caution by lacostenycoder, 30.06.2019 15:45
2
7

We can easily removed local untracked files from the current git working tree by using below git comments.

git reset [--soft | --mixed [-N] | --hard | --merge | --keep] [-q] [<commit>]

Example:

git reset --hard HEAD

Links :

  1. https://git-scm.com/docs/git-reset
  2. How do I use 'git reset --hard HEAD' to revert to a previous commit?
  3. Reset local repository branch to be just like remote repository HEAD
  4. https://jwiegley.github.io/git-from-the-bottom-up/3-Reset/4-doing-a-hard-reset.html
04.12.2017 06:30
Comments
This will also remove changes staged for commit, not only untracked files, which may not be what you want. by raspy, 08.05.2019 10:26
Doesn't work: leaves some files. git clean -ffdx is the solution by Eugene Gr. Philippov, 09.05.2019 14:17
0
6
git clean -f

will remove the untracked files from the current git

git clean -fd

when you want to remove directories and files, this will delete only untracked directories and files

18.05.2018 06:04
1
5

oh-my-zsh with zsh provides those great aliases via the git plugin. They can be used in bash as well.

gclean='git clean -fd'
gpristine='git reset --hard && git clean -dfx'

  • gclean removes untracked directories in addition to untracked files.
  • gpristine hard reset the local changes, remove untracked directories, untracked files and 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.
02.11.2017 08:24
Comments
Thanks for you feedback, my statement was confusing. I wanted to say that the highlighted aliases come automatically with oh-my-zsh. They obviously work great in bash. I edited my answer to reflect that. by Jämes, 31.05.2018 23:35
0
4

I like to use git stash command, later you can get stashed files and changes. git clean is also a good option but totally depends on your requirement. here is the explanation of git stash and git clean,7.3 Git Tools - Stashing and Cleaning

10.11.2018 22:23
0
3

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.

16.12.2016 15:05
0
3

git add --all, git stash and git stash drop, try these three commands in this order inorder to remove all untracked files. By adding all those untracked files to git and stashing them will move all those untracked files to stash list and dropping out top one i.e., stash@{0} will remove the stashed changes from stash list.

14.04.2021 20:18
0
2

I haved failed using most popular answers here - git doesn't delete untracked files from the repository anyway. No idea why. This is my super simplified answer without SPECIAL GIT COMMANDS!

Mission: delete untracked files from git repository:

  1. Move files and folders elsewhere from your local project folder for a while
  2. Delete all lines in .gitignore about these files and folders for the commit
  3. Git add .
  4. Git commit -m “Cleaning repository from untracked files”
  5. Git push

All files and folders has been deleted from the repository.

Lets restore them on localhost if you need them:

  1. Move back all files and folders you have moved temporary to the local project folder again
  2. Move back all lines about these files and folders to .gitignore
  3. Git add .
  4. Git commit -m “Checking or files not appearing again in git repository”
  5. Git push

You are done!

16.08.2018 09:05
1
0

use git reset HEAD <file> to unstage a file

08.08.2017 02:02
Comments
How is this remotely helpful? It doesn't delete any files nor does it do anything to a file which has not been checked into the repo. by lacostenycoder, 30.06.2019 15:43
0
0

If nothing else works, to simply remove all the changes listed by the "git status" command one can use the following combo:

git add -A && git commit -m temp && git reset --hard HEAD^

This will first stage all of your changes then create a temporary commit and then discard it.

24.04.2019 13:18
0
-4

I use this:

  1. git status
  2. copy the path of the file
  3. rm <path of file>

My project has a lot of generated files created by a giant ANT build script. Using git clean would create chaos.

10.06.2019 05:19
0
0

This can be done using a shell script, I use this scrtipt that lists what will be removed, then lets me confirm the operation.

This is useful since I sometimes have patches or other files I'd like to check on before wiping everything away.

#!/bin/bash
readarray -t -d '' FILES < <(git ls-files -z --other --directory)
if [ "$FILES" = "" ]; then
    echo  "Nothing to clean!"
    exit 0
fi
echo -e "Dirty files:\n"
printf '  %s\n' "${FILES[@]}"
DO_REMOVE=0
while true; do
    echo ""
    read -p "Remove ${#FILES[@]} files? [y/n]: " choice
    case "$choice" in
        y|Y )
            DO_REMOVE=1
            break ;;
        n|N )
            echo "Exiting!"
            break ;;
        * ) echo "Invalid input, expected [Y/y/N/n]"
            continue ;;
    esac
done

if [ "$DO_REMOVE" -eq 1 ];then
    echo "Removing!"
    for f in "${FILES[@]}"; do
        rm -rfv -- "$f"
    done
fi
21.12.2019 11:23
0
0

usage: git clean [-d] [-f] [-i] [-n] [-q] [-e ] [-x | -X] [--] ...

-q, --quiet           do not print names of files removed
-n, --dry-run         dry run
-f, --force           force
-i, --interactive     interactive cleaning
-d                    remove whole directories
-e, --exclude <pattern>
                      add <pattern> to ignore rules
-x                    remove ignored files, too
-X                    remove only ignored files
26.08.2020 05:15
0
0

To remove complete changes git clean -f -d

$ git clean -f -d
Removing client/app/helpers/base64.js
Removing files/
Removing package.json.bak

where 
-f is force 
-d is a directory 
10.11.2020 13:23