Bash scripting: test for empty directory

Question

I want to test if a directory doesn't contain any files. If so, I will skip some processing.

I tried the following:

if [ ./* == "./*" ]; then
    echo "No new file"
    exit 1
fi

That gives the following error:

line 1: [: too many arguments

Is there a solution/alternative?

score 317 · Accepted Answer · edited Jul 06 '24 at 10:12

317

if [ -z "$( ls -A '/path/to/dir' )" ]; then
   echo "Empty"
else
   echo "Not Empty"
fi

ls -A means list all but not . or ..

Also, it would be best to check if the directory exists before.

edited Jul 06 '24 at 10:12

llamasaylol

103

answered Oct 31 '11 at 03:53

Andrey Atapin

3,518

slhck · Answer 2 · 2024-06-09T04:18:48.107

48

No need for counting anything or shell globs. You can also use read in combination with find. If find's output is empty, you'll return false:

if find /some/dir -mindepth 1 -maxdepth 1 | read; then
   echo "dir not empty"
else
   echo "dir empty"
fi

edited Jun 09 '24 at 04:18

answered Oct 29 '13 at 21:07

slhck

235,242

score 40 · Answer 3 · edited Jun 19 '18 at 11:11

40

if [ -n "$(find "$DIR_TO_CHECK" -maxdepth 0 -type d -empty 2>/dev/null)" ]; then
    echo "Empty directory"
else
    echo "Not empty or NOT a directory"
fi

edited Jun 19 '18 at 11:11

Vladimir Panteleev

1,813

answered Oct 31 '11 at 10:53

uzsolt

1,305

score 30 · Answer 4 · answered Sep 26 '18 at 13:50

With FIND(1) (under Linux and FreeBSD) you can look non-recursively at a directory entry via "-maxdepth 0" and test if it is empty with "-empty". Applied to the question this gives:

if test -n "$(find ./ -maxdepth 0 -empty)" ; then
    echo "No new file"
    exit 1
fi

score 25 · Answer 5 · answered Nov 01 '11 at 14:51

25

#!/bin/bash
if [ -d /path/to/dir ]; then
    # the directory exists
    [ "$(ls -A /path/to/dir)" ] && echo "Not Empty" || echo "Empty"
else
    # You could check here if /path/to/dir is a file with [ -f /path/to/dir]
fi

answered Nov 01 '11 at 14:51

Renaud

484

score 13 · Answer 6 · edited Oct 30 '23 at 07:14

13

What about testing if directory exists and not empty in one if statement

if [[ -d path/to/dir && -n "$(ls -A path/to/dir)" ]]; then 
  echo "directory exists and is not empty"
else
  echo "directory doesn't exist or is empty"
fi

edited Oct 30 '23 at 07:14

aleb

103
3

answered Jun 20 '18 at 09:17

stanieviv

139

Daniel Beck · Answer 7 · 2013-10-29T21:00:10.860

10

Use the following:

count="$( find /path -mindepth 1 -maxdepth 1 | wc -l )"
if [ $count -eq 0 ] ; then
   echo "No new file"
   exit 1
fi

This way, you're independent of the output format of ls. -mindepth skips the directory itself, -maxdepth prevents recursively defending into subdirectories to speed things up.

edited Oct 29 '13 at 21:00

answered Oct 31 '11 at 10:17

Daniel Beck

111,893

Alois Mahdal · Answer 8 · 2018-09-11T14:44:39.157

A hacky, but bash-only, PID-free way:

is_empty() {
    test -e "$1/"* 2>/dev/null
    case $? in
        1)   return 0 ;;
        *)   return 1 ;;
    esac
}

This takes advantage of the fact that test builtin exits with 2 if given more than one argument after -e: First, "$1"/* glob is expanded by bash. This results in one argument per file. So

If there are no files, the asterisk in test -e "$1"* does not expand, so Shell falls back to trying file named *, which returns 1.
...except if there actually is one file named exactly *, then the asterisk expands to well, asterisk, which ends up as the same call as above, ie. test -e "dir/*", just this time returns 0. (Thanks @TrueY for pointing this out.)
If there is one file, test -e "dir/file" is run, which returns 0.
But if there are more files than 1, test -e "dir/file1" "dir/file2" is run, which bash reports it as usage error, i.e. 2.

case wraps the whole logic around so that only the first case, with 1 exit status is reported as success.

Possible problems I haven't checked:

There are more files than number of allowed arguments--I guess this could behave similar to case with 2+ files.
Or there is actually file with an empty name--I'm not sure it's possible on any sane OS/FS.

ztank1013 · Answer 9 · 2011-10-31T10:19:37.043

This will do the job in the current working directory (.):

[ `ls -1A . | wc -l` -eq 0 ] && echo "Current dir is empty." || echo "Current dir has files (or hidden files) in it."

or the same command split on three lines just to be more readable:

[ `ls -1A . | wc -l` -eq 0 ] && \
echo "Current dir is empty." || \
echo "Current dir has files (or hidden files) in it."

Just replace ls -1A . | wc -l with ls -1A <target-directory> | wc -l if you need to run it on a different target folder.

Edit: I replaced -1a with -1A (see @Daniel comment)

score 6 · Answer 10 · answered Aug 12 '14 at 21:46

6

Using an array:

files=( * .* )
if (( ${#files[@]} == 2 )); then
    # contents of files array is (. ..)
    echo dir is empty
fi

answered Aug 12 '14 at 21:46

glenn jackman

27,524

SpinUp __ A Davis · Answer 11 · 2024-05-09T13:27:02.750

There are lots of good answers here for simple cases, but this QA ranks very highly in a web search, and many of the answers have subtle failures that may be important for some use cases:

permissions problems (i.e. reporting empty dir when it's only unsearchable)
ambiguity about symlinks (test dereferences, find doesn't by default, ls may depend on whether the path ends with /)
answers using shell globbing may rely on options like nullglob that need to be tested or explicitly set

Here is a bash shell function that is efficient for a directory with lots of files, doesn't rely on shell options for globbing, and explicitly tests for permission problems:

mtdir() {
# Robust test for empty directory
# Usage: mtdir &lt;dir_name&gt;
# Return codes:
#   0 : empty
#   1 : non-empty
#   2 : evaluation not possible 

if [[ -d &quot;$1&quot; &amp;&amp; -r &quot;$1&quot; &amp;&amp; -x &quot;$1&quot; ]]
then
    if find -L -- &quot;$1&quot; -maxdepth 0 -type d -empty | grep -q .
    then
        # empty directory
        return 0
    else
        # non-empty directory
        return 1
    fi
else
    # consider printing an error
    echo &quot;argument $1 is not a directory, not readable, or not searchable by this user&quot;
    return 2
fi

}

The function can be used with:

if mtdir some/dir
then
    echo "directory is empty"
    # further processing
fi

You can also test for a non-empty directory explicitly, or an error, using the return code:

mtdir some/dir
ec=$?
if [[ $ec -eq 1 ]]
then
    echo "non-empty directory"
    # further processing
elif [[ $ec -eq 2 ]]
then
    echo "unexpected error: not a directory, not readable, or not searchable"
    # further processing
fi

This function has been tested and works under Linux and macOS, with edge cases of non-directory files, symlinks, and directories with locked down permissions (i.e. chmod 0000 testdir).

As written, valid symlinks are dereferenced (followed), testing the targets rather than the links themselves (both at the -d test, and using find -L). If symbolic links should be tested as link files rather than their target for your application, an explicit test should be added before -d (e.g. ! -L "$1" && ...), and find -P should be used instead of find -L.

score 2 · Answer 12 · answered Apr 15 '20 at 12:41

2

This solution is using only shell built-ins:

function is_empty() {
  typeset dir="${1:?Directory required as argument}"
  set -- ${dir}/*
  [ "${1}" == "${dir}/*" ];
}

is_empty /tmp/emmpty && echo "empty" || echo "not empty"

answered Apr 15 '20 at 12:41

pez

31

score 2 · Answer 13 · edited May 23 '17 at 12:41

I think the best solution is:

files=$(shopt -s nullglob; shopt -s dotglob; echo /MYPATH/*)
[[ "$files" ]] || echo "dir empty"

thanks to https://stackoverflow.com/a/91558/520567

This is an anonymous edit of my answer that might or might not be helpful to somebody: A slight alteration gives the number of files:

files=$(shopt -s nullglob dotglob; s=(MYPATH/*); echo ${s[*]}) 
echo "MYPATH contains $files files"

This will work correctly even if filenames contains spaces.

yarl · Answer 14 · 2018-09-13T16:06:52.453

if find "${DIR}" -prune ! -empty -exit 1; then
    echo Empty
else
    echo Not Empty
fi

EDIT: I think that this solution works fine with gnu find, after a quick look at the implementation. But this may not work with, for example, netbsd's find. Indeed, that one uses stat(2)'s st_size field. The manual describes it as:

st_size            The size of the file in bytes.  The meaning of the size
                   reported for a directory is file system dependent.
                   Some file systems (e.g. FFS) return the total size used
                   for the directory metadata, possibly including free
                   slots; others (notably ZFS) return the number of
                   entries in the directory.  Some may also return other
                   things or always report zero.

A better solution, also simpler, is:

if find "${DIR}" -mindepth 1 -exit 1; then
    echo Empty
else
    echo Not Empty
fi

Also, the -prune in the 1st solution is useless.

EDIT: no -exit for gnu find.. the solution above is good for NetBSD's find. For GNU find, this should work:

if [ -z "`find \"${DIR}\" -mindepth 1 -exec echo notempty \; -quit`" ]; then
    echo Empty
else
    echo Not Empty
fi

HarriL · Answer 15 · 2020-02-16T22:02:41.983

1

The Question was:

if [ ./* == "./*" ]; then
    echo "No new file"
    exit 1
fi

Answer is:

if ls -1qA . | grep -q .
    then ! exit 1
    else : # Dir is empty
fi

edited Feb 16 '20 at 22:02

answered Feb 16 '20 at 18:53

HarriL

19
2

score 1 · Answer 16 · answered Jun 19 '20 at 12:35

1

[ $(ls -A "$path" 2> /dev/null | wc -l) -eq 0 ] && echo "Is empty or not exists." || echo "Not is empty."

answered Jun 19 '20 at 12:35

Mario Palumbo

259

Damien Bono · Answer 17 · 2021-04-17T02:00:50.950

Although there are many reasonable solutions here, I am personally not a big fan of most of these answers, as many return a lot of output when returning directory contents. I was expecting a solution that would better handle directories with large numbers of files, while also one that I think is easy to understand.

So, this is what I ended up with, and thought I would share:

This appears to work OK for me on RedHat:

dir="/tmp/my_empty_dir"
[[ -d "${dir}" && -z "$(find "${dir}" -not -path "${dir}" -print -quit)" ]] && echo "${dir} is empty"

In this example:

First ensure dir exists -d "$dir", otherwise this will return empty (we will also see an error sent to stderr).

However it's likely you would need to test for this separately, as a "not empty" result is likely to mean "contains files" (which is not correct)

AND

Find: (find $dir -not -path $dir -print -quit):

Find everything in $dir
Exclude the directory $dir from the resulting output
Print the first result (something else within $dir)
Quit immediately (only return the first result).

BEWARE the -path parameter takes a "pattern", so if you are expecting special characters (eg: *, [, ]) these would need to be escaped Eg:

dir='/tmp/test[dir]'
dirpath='/tmp/test\[dir\]'
find "${dir}" -not -path "${dirpath}" -print -quit

During my test, this also successfully found hidden files. ($dir/.hidden)

Find returns 0 regardless of whether anything is found, and I don't currently see a simpler way to test this, so:

As per other examples I also wrapped this in:

Empty: [[ -z "$result" ]] to test if the result is blank.

NOT Empty: [[ ! -z "$result" ]] to test if the result is not blank.

Yes, the braces around ${dir} are not really required, but I thought it best to help handle this use case

dir="/tmp/"
[[ -d "${dir}subdir" ...

score 1 · Answer 18 · answered Oct 06 '21 at 09:16

Without calling utils like ls, find, etc.:

Inside dir:

[ "$(echo *)x" != '*x' ] || [ "$(echo .[^.]*)x" != ".[^.]*x" ] || echo "empty dir"

The idea:

echo * lists non-dot files
echo .[^.]* lists dot files except of "." and ".."
if echo finds no matches, it returns the search expression, i.e. here * or .[^.]* - which both are no real strings and and have to be concatenated with e.g. a letter to coerce a string
|| alternates the possibilities in a short circuit: there is at least one non-dot file or dir OR at least one dot file or dir OR the directory is empty - on execution level: "if first possibility fails, try next one, if this fails, try next one"; here technically Bash "tries to execute" echo "empty dir", put your action for empty dirs here (eg. exit).

Checked with symlinks, yet to check with more exotic possible file types.

score 1 · Answer 19 · answered Feb 15 '22 at 00:10

1

Another find solution, (which doesn't rely on other tools), and should be pretty fast:

if (( "$(find /directory/to/check/ -mindepth 1 -printf '1\n' -quit)" )); then
  echo The directory is not empty
else
  echo The directory is empty
fi

answered Feb 15 '22 at 00:10

smac89

474

flabdablet · Answer 20 · 2024-06-07T19:50:14.910

For any directory other than the current one, you can check if it's empty by trying to rmdir it, because rmdir is guaranteed to fail for non-empty directories. If rmdir succeeds, and you actually wanted the empty directory to survive the test, just mkdir it again.

Don't use this hack if there are other processes that might become discombobulated by a directory they know about briefly ceasing to exist.

If rmdir won't work for you, and you might be testing directories that could potentially contain large numbers of files, any solution relying on shell globbing could get slow and/or run into command line length limits. Probably better to use find in that case. The best find solution I can think of goes like

is_empty() {
    test -z "$(find "$@" -maxdepth 0 -not -empty 2>&1)"
}

This works for the GNU and BSD versions of find but not for the Solaris one, which lacks both -maxdepth and -empty options (-empty does what it says; -maxdepth 0 forces find to examine only files and directories supplied explicitly as arguments rather than descending recursively into any directories so supplied).

The slightly convoluted combination of test -z with -not and error message redirection makes is_empty useful for testing multiple directories at once: it will return true only if find emits no output and no errors, which will happen only when all the files it's asked to process exist and are empty regular files or directories (given no arguments at all, it tests the current directory).

If you want a test that returns true only when all its arguments identify empty directories and false when any either don't exist or are non-directories, you could use

is_empty_dir() {
    test -z "$(find "$@" -maxdepth 0 -not \( -empty -type d \) 2>&1)"
}

score 0 · Answer 21 · edited May 02 '18 at 14:00

This work for me, to check & process files in directory ../IN, considering script is in ../Script directory:

FileTotalCount=0

    for file in ../IN/*; do
    FileTotalCount=`expr $FileTotalCount + 1`
done

if test "$file" = "../IN/*"
then

    echo "EXITING: NO files available for processing in ../IN directory. "
    exit

else

  echo "Starting Process: Found ""$FileTotalCount"" files in ../IN directory for processing."

# Rest of the Code

score 0 · Answer 22 · answered Jan 15 '20 at 17:46

0

I made this approach:

CHECKEMPTYFOLDER=$(test -z "$(ls -A /path/to/dir)"; echo $?)
if [ $CHECKEMPTYFOLDER -eq 0 ]
then
  echo "Empty"
elif [ $CHECKEMPTYFOLDER -eq 1 ]
then
  echo "Not Empty"
else
  echo "Error"
fi

answered Jan 15 '20 at 17:46

Alex Sano

9

score 0 · Answer 23 · edited Oct 22 '20 at 21:44

0

I might have missed an equivalent to this, which works on Unix

cd directory-concerned
ls * > /dev/null 2> /dev/null

return-code (test value of $?) will be 2 if nothing or 0 something found.

Note this ignores any '.' files and will probably return 2 if any of these exist without any other 'normal' filenames.

edited Oct 22 '20 at 21:44

Anthony Kong

5,318

answered Oct 22 '20 at 08:39

Tim

1

score 0 · Answer 24 · answered Dec 09 '20 at 17:00

Bash scripting: test for empty directory

27 Answers27

More solutions with `find`

examples

create a sandbox to play in

dir should be empty

create a file in the dir

this will cause the script to fail because the dir is not empty

this line will not execute

output

dir should be empty

create a file in the dir

this will cause the script to fail because the dir is not empty

Related

Bash scripting: test for empty directory

27 Answers27

More solutions with find

examples

create a sandbox to play in

dir should be empty

create a file in the dir

this will cause the script to fail because the dir is not empty

this line will not execute

output

dir should be empty

create a file in the dir

this will cause the script to fail because the dir is not empty

Related

More solutions with `find`