如何测试Linux目录是否只包含一个子目录而没有其他文件？

Question

In a /bin/sh script, I'd like to check whether a directory contains only one subdir and no other files (aside from "." and "..", of course). I could probably parse the output of ls , but I also understand that's generally a bad idea. Suggestions?

Reason for questions: When I zip a folder on, say, a windows machine, and I unzip it under Linux, sometimes I get a directory whose contents are that of the original folder; sometimes I get a directory containing exactly one subdir, whose contents are that of the original folder. (I assume that there's something that varies in the way that I use zip under Windows, or that the various windows machines I use are configured slightly differently, or ...who knows?) Anhow, I'd like, on the Linux side, to handle both kinds of results in more or less the same way, hence this question.

For those thinking "What if your Windows-side folder really did contain just one subdir?", it happens that that's OK in this case, although I grant that it's a corner-case for the problem specification.

Answer 1

find would be a good tool for this. It has some neat arguments:

• -maxdepth 1 so it does not search recursively
• -type d searching only for directories
• -printf 1 to overcome the problem with weird filenames (print 1 instead of the file name)

The full command is then:

find DIRECTORY -maxdepth 1 -type d -printf 1

This will print one character for each directory plus the directory itself so you are looking for directories that prints two characters (find has a nice feature that ignores . and .. when searching).

Then, you want to check if there are no other (non-directory) files:

find DIRECTORY -maxdepth 1 ! -type d -printf 1

The full check will then be:

if [ "$(find DIRECTORY -maxdepth 1 -type d -printf 1 | wc -m)" -eq 2 \
        -a "$(find DIRECTORY -maxdepth 1 ! -type d -printf 1 | wc -m)" -eq 0 ]; then
    # It has only one subdirectory and no other content
fi

Or, you can make it one command using -printf 's %y which prints file type ( d for directory):

if [ "$(find DIRECTORY -maxdepth 1 -printf %y)" = "dd" ]; then
    # It has only one subdirectory and no other content
fi

Answer 2

Your biggest issue in /bin/sh will be invisible files, since a * doesn't catch then [by default].

This will do what you want, I think:

#!/bin/bash
count_()
{
    echo $(( $# - 2 )) # -2 to remove . and ..
}
count()
{
    count_ * .*
}
ITEM_COUNT=$(count)

Of course you can adapt it to take a path as an argument if you wish.

Example output:

bash-3.2$ count
3
bash-3.2$ ll
total 0
drwxr-xr-x   5 christopher  wheel  170 Mar 18  2014 .
drwxrwxrwx   6 root         wheel  204 Jul  5 12:28 ..
drwxr-xr-x  14 christopher  wheel  476 Mar 18  2014 .git
drwxr-xr-x   5 christopher  wheel  170 Mar 18  2014 bin
drwxr-xr-x   4 christopher  wheel  136 Mar 18  2014 pylib

Another example:

sh-3.2$ count_()
> {
>     echo $(( $# - 2 )) # -2 to remove . and ..
> }
sh-3.2$ count()
> {
>     count_ * .*
> }
sh-3.2$ ITEM_COUNT=$(count)
sh-3.2$ echo ${ITEM_COUNT}
3

Sidenote:

You're right that different zip implementations handle things differently, but on Linux, many tools treat zip /path/to/folder and zip /path/to/folder/ differently (which is absurdly irritating) . If you're working in a controlled environment, you might want to instead normalize how things get zipped. However, if this is a user-facing thing, then that sucks.

If you're not using bash as the invoking shell:

countFiles.sh :

#!/bin/bash
count_()
{
    echo $(( $# - 2 )) # -2 to remove . and ..
}
count_ * .*

scriptThatWantsTheCountOfFiles :

#!/bin/tcsh
set count = `./countFiles.sh`

Answer 3

To avoid having to parse output yourself, you can use find .

if [[ `find . -type d | wc -l` -eq 2 && \
      `find . -type f | wc -l` -eq 0 ]]; then

  echo yes

else

  echo no

fi

If you want to avoid recursing into the directory, you can specify -maxdepth 1 .

See man find for some of the other options.

Answer 4

The number of links to the directory inode can help somewhat, but not solve completely the problem. A directory has 2 + n links pointing to it, being n the number of subdirectories created inside. So, if you try to find all the directories with only 3 links, you'll get the directories with only one subdirectory inside. But the only solution to get a no files directory is to search it.

Perhaps you can think in a mixed, two phase solution, in which first you find all the directories with 3 links pointing to them (very efficient). Then you read only those, finding for no plain files inside.

Answer 5

Here's a portable shell function, tested in Dash:

check() {
    d=
    for i in "$1"/* "$1"/.* 
    do
        test ddd != "$d" && test -d "$i" || return 1
        d=d$d
    done
    test ddd = "$d"
}

We use the variable d to count how many directories we've seen. We're expecting three ( . , .. and the target directory). If we've already seen three, then exit early; similarly if we've seen a non-directory.

If we make it to the end of the loop, we check that we've seen three directories; the return value of test becomes the return value of the function.