Removing multiple files from a Git repo that have already been deleted from disk

Question

I have a Git repo that I have deleted four files from using rm (not git rm), and my Git status looks like this:

#    deleted:    file1.txt
#    deleted:    file2.txt
#    deleted:    file3.txt
#    deleted:    file4.txt

How do I remove these files from Git without having to manually go through and add each file like this:

git rm file1 file2 file3 file4

Ideally, I'm looking for something that works in the same way that git add . does, if that's possible.

Solution 1

For Git 1.x

$ git add -u

This tells git to automatically stage tracked files -- including deleting the previously tracked files.

For Git 2.0

To stage your whole working tree:

$ git add -u :/

To stage just the current path:

$ git add -u .

Solution 2

git ls-files --deleted -z | xargs -0 git rm 

might be what you are looking for.. it works for me..

Solution 3

You can use

git add -u

To add the deleted files to the staging area, then commit them

git commit -m "Deleted files manually"

Solution 4

If you simply run:

git add -u

git will update its index to know that the files that you've deleted should actually be part of the next commit. Then you can run "git commit" to check in that change.

Or, if you run:

git commit -a

It will automatically take these changes (and any others) and commit them.

Update: If you only want to add deleted files, try:

git ls-files --deleted -z | xargs -0 git rm
git commit

Solution 5

You're probably looking for -A:

git add -A

this is similar to git add -u, but also adds new files. This is roughly the equivalent of hg's addremove command (although the move detection is automatic).

View more solutions

Comments

[kch]

related: stackoverflow.com/questions/1856654/…

[Brett Ryan]

@seth, it's not always convenient to use git rm, the removal could have been from a separate tool, IDE or file manager. Visual Studio for one can be a pain when removing/renaming files.

[Isabelle Wedin]

Ugh, asking why someone doesn't use git rm is a bit like asking why they don't use git vim or git cd. It's a stupid thing to have to do, and git should have a built-in command or alias to remove deleted files from staging, and you shouldn't have to look it up on SO or read man pages on your lunch break.

[Roland]

Varinder's answer is not a good way. Consider git add -u as Cody suggested and which is also the answer to this question: stackoverflow.com/questions/1402776/…

[Admin]

Possible duplicate of How to add and commit removals made with "rm" instead of "git rm"?

[jbo5112]

@Roland git add -u will add all modified files that are being tracked. It make work because of circumstances (everything else has been committed), but if you're hoping it will just synchronize your deletes, then you may have some work finding the proper commit for some edits later.

[SpoonMeiser]

Not sure why I got down-voted; git does a good job of identifying files that have been deleted, even if you've not explicitly told it by using git rm.

[carl]

While it'll work, I often find myself deleting a ton of files through just rm and regretting it later.

[Igor Zevaka]

Right, git commit -a will do what I want, except in some cases I have files that I don't want to commit, so i want to prepare the commit manually.

[Emil Sit]

commit -a essentially does an "add -u" first; it will update the index with any changes to known files (be they deletions or simple changes). You can of course be more specific and add/rm only the files you want. git.or.cz/gitwiki/… may be helpful.

[Ian Hunter]

Note that this will add all changed, tracked files--deleted and updated.

[Jay Taylor]

The commandset beneath the "Update: .." worked like a charm. Thanks!

[Keegan Crain]

Please note Google user: It adds the modified tracked files to the staging area as well.

[mit]

Thank you so much for 'git ls-files --deleted | xargs git rm' !

[Paul Prewett]

@beanland, you need only provide the path to the specific file you want to modify if you don't want it to get them all. e.g. git add -u [path]

[spaaarky21]

On a quick side note, using -u limits the add to tracked files and -a will include untracked files as well. Just thought I would point out the difference.

[Ian Dunn]

Why is this worse than doing git add -u? It seems like it'd be safer to add the specific files that were deleted to the commit, rather than adding ALL changes.

[Eric Wilson]

@Saeb Understand about the queue, but xargs is about 15 minutes to master.

[c..]

also git add -u folder/ to run this operation in a folder

[Aryo]

Run this command only if you had just removed the files and want to stage them immediately.

[reto]

"git ls-files --deleted | xargs git rm" is the correct answer! Thanks!

[Dan]

for windows try to add the following alias in your config without the quotes as stated above by Evan Moran 'remove = !git ls-files --deleted -z | xargs -0 git rm'

[flq]

That is actually the correct answer since -u also adds modified tracked files to the index.

[Mark Reed]

git status | awk '/deleted/ {print $3}' | xargs git rm would be a shorter way to do that. grep | awk... Just Say No.

[Sheharyar]

You got down-voted because "-a" is not an acceptable switch, it's "-A". Editing your answer.

[SpoonMeiser]

No, "-a" is an acceptable switch, because the command is commit. "-A" is a switch to add but not commit. I see your suggested edit has already been rejected.

[Ramsharan]

actually this should be the best answer according to the question's last line "I just want a command that deletes all files from git that are also deleted from the disk."

[Hotschke]

git rm $(git ls-files --deleted) isn't this more convenient ( copied from this).

[Casey]

and from cmd line git config --global alias.rmd '!git ls-files --deleted -z | xargs -0 git rm'

[Adam]

"git ls-files" is incorrect: this outputs filenames with literal spaces, that breaks the next part.

[Adam]

@Ramsharan no, because it doesnt do that at all. This deletes a single file; the OP SPECIFICALLY requested "all" deleted files.

[Emil Sit]

@Adam I've updated the syntax with flags that will parse correctly in xargs.

[Ramsharan]

@Adam You are right. This single command cannot delete "all" deleted files. You have to run this command multiple times for multiple files. But you can use wild-card to delete multiple files.

[Adam]

@Ramsharan no, that's the point - in almost all cases you CANNOT simply use a wildcard (there is no wildcard that will match). This is why there's the main answer is so much more complicated.

[Ramsharan]

@Adam The main thing is I use "git rm filename" or "git rm folder/*" normally in my project. And normally it is enough for me.

[maazza]

be wary of files with spaces in their name

[galarant]

git commit -a -u -m 'commit message' will stage all changes including deletions, and commit all in one line

[Travesty3]

I can't believe this response got so many upvotes. All it did was give the basic command from the manual to remove one file at a time. The question asked for something "Similar to git add . which would add all new and modified files to the stage." This does not answer the question at all.

[Dave Everitt]

@maazza - how do you handle files with spaces in their name?

[B T]

Huh, this is not working for me on git 1.8.1.msysgit.1 on windows 7 32-bit. Maybe I need to way git add -u *?

[Andrew]

xargs or the above $() substitution if you know the list isn't huge. If the list is huge: git ls-files --deleted | while read f; do git rm $f; done

[Max Nanasy]

@DaveEveritt git ls-files --deleted -z | xargs -0 git rm

[Jakub M.]

bit more elegant:git status | awk '/deleted/{print "git rm " $3}' | sh

[Dennis]

Well using a gui is CHEATING, lol! But faster in the cases where the GUI designer covered your needs. It is good to know how to tinker with 'what is under the hood'.

[fazy]

Preview version of Saeb's answer for the nervous: for x in ``git status | grep deleted | awk '{print $3}'``; do echo $x; done (replace double backticks with single ones); SO's markup escaping doesn't seem to work.

[Ajedi32]

@Andrew xargs is probably more efficient than a while loop for a huge list, since it passes more than one argument each time it executes git rm. To limit the number of arguments passed to git rm each time it is executed, use the -n option: git ls-files --deleted | xargs -n 15 git rm

[Andrew]

@Ajedi32 learned something new: xargs -n is very winning. Thanks!

[Popnoodles]

@maazza please don't radically change answers. This one is three-year-old. The change should not have been approved.

[Sawyer]

'git ls-files --deleted | sed 's/(.*)/"\1"/'| xargs git rm' for the situation when the file path has space

[AJP]

Please see @Hotschke's git rm $(git ls-files --deleted) comment on Saeb's answer.

[Tara Roys]

This command no longer works for git 2.0. According to the error message I got when I tried it, the proper command is git add --update :/

[Roland]

git add -u as Cody suggested is a much simpler and safer way, no risk of accidentally deleting files.

[donkey]

I think I have a problem using the solution mentioned above because i have so many deleted files(discarded sub-project), it literally tells me -bash: /usr/bin/git: Argument list too long. Answer should be @MaxNanasy 's/

[MIWMIB]

I also like using git clean -f -d before issuing git add -u when I don't have any new files to start tracking.

[Shog9]

FYI: this answer merged from stackoverflow.com/questions/1402776/…

[Shog9]

FYI: this answer merged from stackoverflow.com/questions/1402776/…

[Shog9]

FYI: this answer merged from stackoverflow.com/questions/1402776/…

[Shog9]

FYI: this answer merged from stackoverflow.com/questions/1402776/…

[Shog9]

FYI: this answer merged from stackoverflow.com/questions/1402776/…

[TheWarriorNamedFoo]

The top-voted answer already says to use git add -u. Where does all of the other stuff in your answer come from, the documentation? You should link to the documentation and blockquote it if it does.

[SteveShaffer]

Seems to be working on PowerShell (not git shell or anything, just generic PowerShell with git.exe installed) and it worked!

[Julien Palard]

Won't work with files containing spaces in their name. Use git add -u instead shorter and safer.

[Shawn Whinnery]

Would you please elaborate on what this does?

[Zac Grierson]

At this stage you might as well add all via the commit -a flag.

[Rafael Eyng]

git ls-files --deleted yields all files with status deleted. For each deleted file, git does a git rm.

[n13]

Downvoting this as it is the wrong answer even if it might work for some files. use "git add -u" below. That's what it's for.

[kmarabet]

git add --all && git commit -m "Your commit" This worked for me in windows-7, using Git bash command shell.

[kmarabet]

The following command worked for me in windows-7, using Git bash command shell: $ git add --all && git commit -m "remove property files" [master 58c41ac] remove property files 1 file changed, 9 deletions(-) ... Then to push those committed changes to the remote repository have run: $ git push origin .. Counting objects: 10, done.

[Hossam Badri]

I think you should always use git shell on you current working directory

[DrB]

This is nice and simple but doesn't work with recursive folders.

[Hossam Badri]

@BehnazChangizi I think it does, stackoverflow.com/questions/1054044/…

[Relequestual]

It might be the question people were asking when they arrived at this page, and it might be what the OP actually meant to ask, but it doesn't answer the exact question asked.

[Hossam Badri]

@PvdL not accepted spaces in the path is os-specefic problem

[maxkoryukov]

such a simple action, and this difficult enough solution.. git-way

[David Grayson]

Windows users should get MSYS2 or "Git for Windows" so they can run a normal bash environment (like the rest of the world) and use this command.

[iratzhash]

this does not help when there are spaces in filenames.

[9ilsdx 9rvj 0lo]

Downvote because the solution is dangerous and instable. A pity it's accepted by the OP.

[srinivas gowda]

i am not able to remove file from bitbucket repo]

[David Rogers]

FYI: some of the deleted files may show up as renames using this technique if, for example, the same file now exists (added) in a different (added) directory.

[billrichards]

In case the only thing you're committing is the deleted file, add the switch --allow-empty

[billrichards]

err, actually --allow-empty is only needed if you did git rm --cached

[mlncn]

Wildcards weren't working for me with git add -u path/to/my/deleted-files-pattern-*.yml so this was the best answer for me (not wanting to stage all deleted files, but 50 out of a couple hundred).

[jbo5112]

git add -u will add files that have either been updated or deleted. It could cause problems for people trying to sort out their changes, so it shouldn't be the proper answer. Also, I'm glad the update stood. Using <cmd1> | xargs <cmd2> instead of <cmd2> $(<cmd1>) is not a radical change @Popnoodles, and it works better. Remember, in order for stackoverflow to be useful, people need to easily find good answers. Even at 8.5 years old, this answer was my first solid search result on Google, so don't act like the information went bad.

[jbo5112]

Adding all tracked files that have been updated is probably not what you want. I hope you don't actually need to revert to something you accidentally committed under this. It might be hard to track down under a comment of something like "removing deleted files from git".

[bbennett36]

WARNING: THIS DELETES THE FILES ON DISK TOO. I just accidentally deleted tons of files...

[user151841]

2019 git version 2.13.3: git diff --diff-filter=D --name-only | xargs git rm

[jlh]

Awesome! You may want to add -r to xargs, so it won't fail if there happens to not be any deleted file.

[ElectricErger]

IMO reset is the best one since you could have deleted the file. It's too bad that there's 1000 upvotes on add.