removing the contents of a directory
 

Is there a way in terminal to remove all the contents of a folder, but not the folder itself? If not, perhaps an easy way to do it in Applescript? Thanks.
-Bell

Yes.


rm -r /path/to/folder/
don't forget that trailing slash.

thanks baf, but your idea doesn't work, it still deletes the folder. However, it got me thinking and I believe I figured it out. Use this:

rm -r /path/to/folder/*

That seems to do the trick. Thanks again.

Be very careful when typing that. The combination of 'rm' and '*' on the same line, especially in the presence of '-rf', should make you at least as nervous as using both hands to work on high voltage equipment.

Because it's scary, I'll break it down and explain the pieces, on the theory that an incantation you understand is easier to type correctly:

• rm remove the following items
• -rf a combination of:
  • -r recursing into directories
  • -f forcing your way past easily-circumvented problems. (For example, if a non-empty subdirectory is non-writable, but you have permission to make it writable, just go ahead and do that without nagging you about it.)
• * everything in the current directory whose name does not begin with a period
• .[^.] and everything whose name is a period followed by a non-period
• .??* and everything that starts with a period and is at least three characters long.

The net effect is to remove everything in the current directory except '.' (the directory itself) and '..' (its parent).

That doesn't remove files whose names begin with period. ('*' won't match those.) For example, it leaves behind .DS_Store, and things like .svn (subversion directories).

Can I ask a supplementary question to this topic please?

How would one delete all files in a folder that are older than say 3 months?

find /path/to/folder \! \( -newerct '3 months ago' \) -delete

Of course test it without the destructive option :D

Thanks acme but it doesn't seem to work. My unix is not so hot but do I really put '3 months ago' into the command?

Yes it should work with that syntax. Try copying that line except -delete and replace path to folder with something else.

kaptagat, if it doesn't work the next time, please copy/paste from your Terminal the exact command you entered and the exact results, so we can see where it went wrong.

Trevor

Somewhere along the line, rm has been adjusted to compensate for the ".*" predicament.
Shell prints an error:
But your regex " * .[^.] .??* " is still a smart idea.
(we can't always be sure the local rm has that particular feature)

-HI-

cd /path/to/folder
/bin/rm -rf * .*

You do indeed. find will interpret almost any reasonable text string and change it into a date. You copied all the parentheses and backslashes, yes?

Right... but as mentioned above: on some systems (Panther maybe?),
that might also delete stuff in the *parent* folder. Just try it with ls to
see what could happen (on other systems):

$ cd ~/.Trash
$ ls * .*
ls: *: No such file or directory
.:

..:
Applications Documents Library Music Private Sites
Desktop Downloads Movies Pictures Public bin

:eek:
The shell's pattern matching facility will include stuff in the parent (..*)
ls just lists what the shell "asked" it to.

So, further design is required, to filter out all ..* matches that occur.
rm wasn't always so thoughtful to do that, as it appears to be today.

--

For example!!! :: DANGER :: Apple's own srm does not seem friendly in that regard!!!

Taking a cue from ganbustein,
this also seems to do the trick:

rm * .[^.]*

Nah. I made it as short as possible. Your pattern won't match and remove items named ... or ..secret_stash. And yes, I have seen such names used.

Excellent!

Interesting rm safety note: Keeping files called "-r" in directories can be a Bad Idea (not that I'm sure why you would have this file, or if there would be a situation where you'd think it'd be a good idea to use "rm *" in a directory to remove the top level files but keep everything lower down the directory tree).

Keeping a file called "-i" in a folder will definitely stop you rm-ing anything by mistake, but it's a pain in the backside if you do actually want to delete a bunch of stuff without confirmation.

I think the trick there is to use the folder's full pathname
especially when we're 'parked' in the directory at the time.

Wrapping ganbustein's magical patterns with some brace expansion syntax,
and applying a $PWD preamble, we could do...

ls -l "$PWD"/{*,.[^.],.??*}

Simply change ls -l to rm -r ...after a full backup! :D
[just kidding -- the listing looks perfectamundo]

--

Or hell... full path not needed to dust off "-i" files.
A basic ./ should do it:
rm -r ./{*,.[^.],.??*}

I just noticed something interesting.
Both "..." and "..secret_stash" are visible in Finder!
:rolleyes:

That's bizarre!

As for dealing with -r and -i files... as man rm mentions, rm uses getopt() to parse its arguments, so the usual -- option works.

rm -rf -- * .[^.] .??*

Hmm.. without that, a file named -- might prevent an unpredictable subset of your files from being deleted.

Of course, prefixing with ./ works also on systems where rm does not look for --.

Back in the olden days when I was learning Unix, I seem to recall that ? would not match a period. My first attempt was

rm -rf * .? ..?* ...*

but ? doesn't work like that anymore (if it ever actually did). I just thought I'd mention that.

This thread seems to be accentuating that every program still has at least one bug, even if the program is a one-liner. Anyone but me remember IEFBR14? Of course you can google it, but do you remember it without looking it up? (I don't know if the fact that today is my 62nd birthday, and I've been programming since I was 19, makes that easier or harder to remember.)

Oh yeah... I'd forgotten about "--"

--

I found we can also circumvent the "-i" effect by changing the order so that the
bare asterisk is not first. For example... using ls with the -f option (to force it
to list items in the order they were submitted):
Since the early * picked up the "-i" first, ls saw it as an (inode) option.
So the -i file isn't shown.

Now, reordering...
(-f wasn't necessary; it merely helped to reflect the actual input, which echo also showed).

As can be seen, I've been playing around with some other weird filenames: .* and .\*

I know you didn't mean it this way, but if we are going for short (not to mention easier to type), it'd be better to use the following to delete all files & folders in the current directory:

find . -delete

That's weird... find . -delete
finds '.' but it doesn't delete '.'
How come (no error nothin')?

It's merely that 'delete' is smart enough to know that it wouldn't make sense to delete the current directory. So it makes an exception for '.' and '..' - here's the relevant part of the source code:

^^^

Well, there's still something to be said for the pattern approach:
it can be done from *outside* the folder. (I've already added a
Bash function to implement it... so it needs to be rationalized).

rm -fr foo/{.[^.],.??*,*}

will clear foo's content, but folder foo survives. ;)

It's true that I didn't mean it that way, but your version is not only shorter and easier to remember/type/understand, it's also more robust.

The difference is that rm * forces bash to expand the complete list of files before handing it to rm, and the list is too long for IPC to handle. With find, -delete deletes each item immediately. No list needs to be created. I yield to the superior solution.

Hal: here's a start on your function:I found that I kept getting errors out of find when I tried find "$1" -delete or variations thereof. For one thing, while find . -delete won't find and delete '.', find foo -delete will happily find and delete 'foo'. Say what? And $1 might or might not have a trailing slash. And after that there are warnings about relative pathnames, at which point I threw in the towel and just did a cd.

Add whatever additional error-checking code you deem appropriate. A nice refinement might be to loop across "$@" instead of just using "$1". Or have it accept files as well as directories.

Or just ask yourself how often you're really going to need this. After all:

rm -rf someDirectory
mkdir someDirectory

will almost always be good enough.

[shhhh... we don't want folks to think this stuff can be that simple.] ;)

Can I ask to go on another tangent? :)

I would like to be able to remove all the thumbnail files iPhoto creates. In each "primary" folder hierarchy ~/Pictures/iPhoto\ Library/<year>/<month>/ there can be a "Thumbs" directory containing these thumbnail files. I've been trying to use a combination of 'find' (to find the "Thumbs" directory and 'xargs' to delete the contents of these folders, but I can't seem to get it to work. As usual, I'm sure I'm overlooking something quite simple...

TIA

This one is very aggressive, the Four Horsemen of `find` annihilating entire directory trees at a stroke:

find . -iname '*thumb*' -exec rm -rf {} \;

Only two horses:

find . -type d -name thumb -exec rm {}/*jpg \;

Hmmm, I thought I'd tried those combinations, without success. It looks like the second would do the trick. I'd change it to

find . -type d -name Thumbs -exec rm {}/*jpg \;

Simply to guard against the possibility (however unlikely) that there might be a folder with "thumb" somehow in its name.

Thanks!