Mfcttrf

To find all directories that contain no other name than *.tmp, desktop.ini, Thumbs.db, and/or .picasa.ini:

find . -type d -exec bash -O dotglob -c '
 for dirpath do
 ok=true
 seen_files=false
 set -- "$dirpath"/*
 for name do
 [ -d "$name" ] && continue # skip dirs
 seen_files=true
 case "$name##*/" in
 *.tmp|desktop.ini|Thumbs.db|.picasa.ini) ;; # do nothing
 *) ok=false; break
 esac
 done

 "$seen_files" && "$ok" && printf "%sn" "$dirpath"
 done' bash +

This would use find to locate any directories beneath the current directory (including the current directory) and pass them to a shell script.

The shell script iterates over the given directory paths, and for each, it expands * in it (with the dotglob shell option set in bash to catch hidden names).

It then goes through the list of resulting names and matches them against the particular patterns and names that we'd like to find (ignoring directories). If it finds any other name that doesn't match our list, it sets ok to false (from having been true) and breaks out of that inner loop.

The seen_files variable becomes true as soon as we've seen a file. This variable helps us avoid reporting subdirectories that only contain other subdirectories.

It then runs $seen_files and $ok (true or false) and if these are both true, which means that the directory contains at least one regular file, and only contains filenames in our list, it prints the pathname of the directory.

Instead of

set -- "$dirpath"/*
for name do

you could obviously do

for name in "$dirpath"/*; do

instead.

Testing:

$ tree
.
`-- dir
 |-- Thumbs.db
 `-- dir
 |-- file.tmp
 `-- something

2 directories, 3 files

(find command is run here, producing the output...)

./dir

This means that the directory ./dir only contains names in the list (ignoring directories), while ./dir/dir contains other things as well.

If you remove [ -d "$name" ] && continue from the code, the ./dir directory would not have been found since it contains a name (dir) that is not in our list.

You would need to specify the files or folders, ideally by name, like:

find $HOME -type f -iname thumbs.db -print0 | xargs -0 --no-run-if-empty rm

will find all files (-type f) called (-iname) "thumbs.db" (ignoring case because of the i in iname) and then removing (rm) them.

You may use filename patterns, e.g.

find $HOME -type f -iname '*.tmp' -print0 | xargs -0 --no-run-if-empty rm

Warning: Please be careful what you type, deleting may happen without asking you.

Do make regular backups - right before getting to work on your cleanup may be a good moment!

If you wish to find out what would happen look at the file list first before rming anything, like:

find $HOME -type f -iname thumbs.db -print0 | xargs -0 --no-run-if-empty ls -l

Used this combination of find, xargs, ls, sed, wc and awk commands and it is working:

find . -type f ( -iname "desktop.ini" -o -name "thumb.db" ) -printf %h\0 | xargs -0 -I "" sh -c 'printf "t"; ls -l "" | sed -n "1!p" | wc -l' | awk '$2 == "1" print $0'

Explanation:

• 
  find . find in current directory


• 
  -type f find files only


• 
  ( -iname "desktop.ini" -o -name "thumb.db" )where filename is "desktop.ini" or "thumb.db" case insensitive


• 
  printf %h\0 print leading directory of file's name + ASCII NUL


• 
  xargs -0 -I "" sh -c 'printf "t"; ls -l "" print output directory and execute ls -l on each one


• 
  sed -n "1!p" | wc -l' exclude first line of ls -l which contain total files and directories and then count lines


• 
  awk '$2 == "1" print $0' print line if only count is equal to "1"

With zsh, you can do

set -o extendedglob
printf '%sn' **/*(D/^e'[()(($#)) $REPLY/^(*.tmp|desktop.ini|Thumbs.db|.picasa.ini)(ND)]')

To list the directories that do not contain entries other than (*.tmp|desktop.ini|Thumbs.db|.picasa.ini) ones, so would report empty directories and directories containing only this kind of entries.

• 
  **/: recursive glob (any level of subdirectories)


• 
  *(qualifier): glob (here * matching any file), with qualifiers (to match on other criteria than name).


• 
  D: enable dotglob for that glob (include hidden files and look inside hidden dirs).


• 
  /: only select files of type directory
  


• 
  ^: negate the following qualifiers


• 
  e'[code]': an evaluation qualifier: select the files for which the code does not (with the previous ^) return true.


• 
  () code args: anonymous function. Here the code is (($#)) which is a ksh-style arithmetic expression which here evaluates to true if $# is non-zero ($# being the number of arguments to the anonymous function).


• 
  $REPLY/^(*.tmp|desktop.ini|Thumbs.db|.picasa.ini)(ND) makes up the arguments to that inline function. Here that's another glob:


• 
  $REPLY: inside the e'[code]' that's the path to the file currently being considered.


• 
  ^: negation (that's the operator for which we need extendeglob).


• 
  (*.tmp|desktop.ini|Thumbs.db|.picasa.ini): either of those, so with negation, none of those. You can prefix it with (#i) if you want case-insensitive matching.


• 
  (ND): another glob qualifier. N for nullglob (the glob expands to nothing if there's no match, so (($#)) becomes false), D for dotglob again.

If you don't want to include empty directories, add the F glob qualifier (for Full)

With GNU find and GNU awk, you could have find report all the files and awk do the matching:

find . -depth -type d -printf '%p/' -o -printf '%p' |
 gawk -F/ -v OFS=/ -v RS='' -v IGNORECASE=1 '
 //$/ 
 NF--
 if (good[$0] == 0 && bad[$0] > 0) print
 next
 
 .picasa.ini)/)
 bad[$0]++
 else
 good[$0]++
 '

If you also want to include the empty directories, remove the && bad[$0] > 0. If if you want case sensitive matching, remove -v IGNORECASE=1.