Delete folders which not match a list

Question

I need practical example how get rid folders which are not in the list in Linux. So i do not need to compare its contents or md5sums, just compare folders names.

For example, one folder has few folders inside

target_folder/
├── folder1
├── folder2
├── folder3
└── folder4

and my folders name list is txt file, includes folder1, folder2 and not folder3 and folder4.

How to remove folder3 and folder4 via bash script?

This has been answered on serverfault as

GLOBIGNORE=folder1:folder2
rm -r *
uset GLOBIGNORE

but my real task to delete bunch of folders. The txt list contains around 100 folders and target folder to clean is 200 folders.

Note that this should work both in Linux and FreeBSD.

EDIT: target_folder may contain folders with sub-folders and also files. No spaces and leading dots and names are not similar: foo.com bar.org emptydir file.txt simplefile. But all these items should be deleted except those names in the list.

First answer is more obvious and simple. Second one more advanced and flexible, it allows you to delete based on item type as well.

Answer 1

Assuming your file names do not contain any of :\[*?, you could still use GLOBIGNORE. Just format your list of directories accordingly. For example:

$ cat names.txt
folder1
folder3

That is very easy to transform into a colon separated list:

$ paste -s -d : names.txt
folder1:folder3

So, you can now set that as the value of GLOBIGNORE:

GLOBIGNORE=$(paste -s -d : ../names.txt)

And proceed to delete them normally:

rm -r -- *

I just tested this on Linux with 300 directories and it worked perfectly.

Answer 2

How about this?

find ./target_folder/ \
    -mindepth 1 \
    -maxdepth 1 \
    -type d \
    -not -name 'anything[0-9]*' \
    -exec rm -rf {} \;

Let me explain:

• -mindepth 1 makes sure you don't match ./target_folder/
• -maxdepth 1 makes sure you don't match any subfolders.
• -type d tells find to only match directories, and not files.
• -not -name 'anything[0-9]*' excludes from the pattern anything that matches the pattern. Pretty obvious, that one.
• -exec is to be used with care, especially when it involves rm. You should always test this using echo before going ahead and rm -rfing stuff this way. find can be tricky to
• Don't forget the trailing \; when using exec.

You can read the find manual page for more info. It's an extremely handy tool.

Answer 3

A simple approach is to list all files and ignore the ones that are in the list file. Note that I arrange for the variable ignore_list to start and end with a newline, so that I can check if $x is included in a simple way (just checking that $ignore_list contains $x doesn't work, since it would also match files whose name is a substring of an element of the ignore list).

newline='
'
ignore_list="$newline$(cat list.txt)$newline"
cd target_folder
for x in * .[!.]* ..?*; do
  case "$x" in *"$newline"*) continue;; esac   # sanity check: if the file name contains a newline, leave it alone
  case "$ignore_list" in
    *"$newline$x$newline"*) echo "Skipping $x";;
    *) rm -rf -- "$x";
  esac
done

Answer 4

Another solution that matches begin and end of the folder names:

IFS=$'\n'

folders="""folder1
folder2"""

for folder in *; do
    found=0
    if [ -d "$folder" ]; then
        for i in $folders; do
            if [ $(echo "$folder" | grep -c -E "^$i\$") -eq 1 ]; then
                found=1
            fi
        done
        if [ $found -ne 1 ]; then
            echo "$folder found and deleted."
            rm -rf "$folder"
        fi
    fi
done

Answer 5

You can do it in bash like

for folder in /target_folder/*/
do
    folder=${folder%/}
    if ! grep -qx "${folder##*/}" folders_list.txt
    then
        rm -rf "$folder"
    fi
done

Answer 6

With zsh (note that GLOBIGNORE is bash-specific, neither bash nor zsh are installed by default on FreeBSD, but both are available):

(cd /target_folder || exit
all_dirs=(*(/))
to_exclude=(${(f)"$(<names.txt))"})

rm -rf -- ${all_dirs:|to_exclude})

The zsh-specific features:

• *(/). (/) is a glob qualifier that means only select the files of type directory.
• $(<file): expands to the content (minus the trailing newline characters) of file (comes from ksh, bash also has it but does fork a process to read the content of file there).
• ${(f)...}. That's a parameter expansion flag that splits the "$(...)" expansion on line feeds. With bash, you'd need to do something like: IFS=$'\n'; set -f; to_exclude=($(<names.txt)) instead.
• ${A:|B} expands to the elements of the $A array that are not also in the $B array.

Answer 7

On a GNU or FreeBSD system, you can do:

cd /target_folder &&
  printf '%s\0' * | grep --null -vxFf names.txt | xargs -r0 rm -rf