<<Anchor(faq4)>>
== How can I check whether a directory is empty or not?  How do I check for any *.mpg files, or count how many there are? ==
In Bash, you can count files safely and easily with the `nullglob` and `dotglob` options (which change the behaviour of [[glob|globbing]]), and an [[BashFAQ/005|array]]:

{{{#!highlight bash
# Bash
shopt -s nullglob dotglob
files=(*)
(( ${#files[*]} )) || echo directory is empty
shopt -u nullglob dotglob
}}}

See ArithmeticExpression for explanations of arithmetic commands.

Of course, you can use any glob you like instead of `*`.  E.g. `*.mpg` or `/my/music/*.mpg` works fine.

Bear in mind that you need [[Permissions|read permission]] on the directory, or it will always appear empty.

Some people dislike `nullglob` because having unmatched globs vanish altogether confuses programs like `ls`.  Mistyping `ls *.zip` as `ls *.zpi` may cause every file to be displayed (for such cases consider setting `failglob`).  Setting `nullglob` in a SubShell avoids accidentally changing its setting in the rest of the shell, at the price of an extra `fork()`.  If you'd like to avoid having to set and unset shell options, you can pour it all into a SubShell:

{{{#!highlight bash
# Bash
if (shopt -s nullglob dotglob; f=(*); ((! ${#f[@]}))); then
    echo "The current directory is empty."
fi
}}}

The other disadvantage of this approach (besides the extra `fork()`) is that the array is lost when the subshell exits.  If you planned to ''use'' those filenames later, then they have to be retrieved all over again.

Both of these examples expand a glob and store the resulting filenames into an [[BashFAQ/005|array]], and then check whether the number of elements in the array is 0.  If you actually want to ''see'' how many files there are, just print the array's size instead of checking whether it's 0:

{{{#!highlight bash
# Bash
shopt -s nullglob dotglob
files=(*)
echo "The current directory contains ${#files[@]} things."
}}}

You can also avoid the `nullglob` if you're OK with putting a non-existing filename in the array should no files match (instead of an empty array):

{{{#!highlight bash
# Bash
shopt -s dotglob
files=(*)
if [[ -e ${files[0]} || -L ${files[0]} ]]; then
    echo "The current directory is not empty.  It contains:"
    printf '%s\n' "${files[@]}"
fi
}}}

Without `nullglob`, if there are no files in the directory, the glob will be added as the only element in the array.  Since `*` is a valid filename, we can't simply check whether the array contains a literal `*`.  So instead, we check whether the thing in the array ''exists'' as a file.  The `-L` test is required because `-e` fails if the first file is a [[BashFAQ/097|dangling symlink]].

If you don't care how many matching files there are and don't want to store the results in an array, you can use bash's `compgen` command.  Unfortunately, due to a [[https://lists.gnu.org/archive/html/bug-bash/2023-03/msg00062.html|bug]], you need to use a hack to make it recognize `dotglob`:

{{{#!highlight bash
# Bash
if (shopt -s dotglob; : *; compgen -G '*' >/dev/null); then
    echo "The current directory is not empty."
else
    echo "The current directory is empty."
fi
}}}

Or you can use an [[glob#extglob|extended glob]]:

{{{#!highlight bash
# Bash
# The subshell may be avoided by enabling extglob for the whole script.
# Doing so should be safe.
if (shopt -s extglob; compgen -G '@(*|.[!.]*|..?*)' >/dev/null); then
    echo "The current directory is not empty."
else
    echo "The current directory is empty."
fi
}}}

You may also use `failglob`:

{{{#!highlight bash
# Bash
if ( shopt -s dotglob failglob; : ./* ) 2>/dev/null; then
    echo "The current directory is not empty."
else
    echo "The current directory is empty."
fi
}}}

But, if you use `failglob`, note that the subshell is required; the following code does not work because failglob will raise a shell error that will cause bash to stop running the current command (including the `if` command, any outer compound command, and the entire function that ran this code if it is part of a function), so this will only work in the true case, the `else` branch will never run:
{{{#!highlight bash
# BROKEN!
shopt -s dotglob failglob
if { : ./* ;} 2> /dev/null; then
    echo "The current directory is not empty."
else
    echo "The current directory is empty."
fi
}}}

If you really want to avoid using the subshell and want to set failglob globally, you can either "catch" the shell error using `command eval`, or you can write a function that expands the glob indirectly:
{{{#!highlight bash
shopt -s dotglob failglob
if command eval ': ./*' 2> /dev/null; then
    echo "The current directory is not empty."
else
    echo "The current directory is empty."
fi
# or
shopt -s dotglob failglob
any_match () { local IFS=; { : $@ ;} 2> /dev/null ;}
if any_match './*'; then
    echo "The current directory is not empty."
else
    echo "The current directory is empty."
fi
}}}

If your script needs to run with various non-Bash shell implementations, you can try using an external program like python, perl, or [[UsingFind|find]]; or you can try one of these. Note the "magic 3 globs"<<FootNote(https://www.etalabs.net/sh_tricks.html)>> as POSIX does not have the `dotglob` option.

{{{#!highlight bash
# POSIX
# Clobbers the positional parameters, so make sure you don't need them.
set -- * .[!.]* ..?*
for f in "$@"; do
  if test -e "$f" || test -L "$f"; then
    echo "directory is non-empty"
    break
  fi
done
}}}
At this stage, the positional parameters have been loaded with the contents of the directory, and can be used for processing.

If you just want to count files:

{{{#!highlight bash
# POSIX
n=0
for f in * .[!.]* ..?*; do
  if test -e "$f" || test -L "$f"; then n=$((n+1)); fi
done
printf "There are %d files.\n" "$n"
}}}

In the Bourne shell, it's even worse, because there is no `test -e` or `test -L`:

{{{#!highlight bash
# Bourne
# (Of course, the system must have printf(1).)
if test "`printf '%s %s %s' .* *`" = '. .. *' && test ! -f '*'
then
    echo "directory is empty"
fi
}}}

Of course, that fails if `*` exists as something other than a plain file (such as a directory or FIFO).  The absence of a `-e` test really hurts.

Here is another solution [[UsingFind|using find]]:

{{{#!highlight bash
# POSIX
# Print a single `.' for each file and count the number of characters printed.
# This one will recurse.  If that is not desired, see below.
n=$(find . -type f -exec printf %.0s. {} + | wc -m)
printf "There are %d files.\n" "$n"
}}}

If you want it not to recurse, then you need to tell find not to recurse into directories.  This gets really tricky and ugly.  GNU find has a `-maxdepth` option to do it.  With standard POSIX find, you're stuck with `-prune`.  This is left as an exercise for the reader.

Never try to [[ParsingLs|parse ls output]].  Even `ls -A` solutions can break (e.g. on HP-UX, if you are root, `ls -A` does the exact ''opposite'' of what it does if you're not root -- and no, I can't make up something that incredibly stupid).

In fact, one may wish to avoid the ''direct'' question altogether.  Usually people want to know whether a directory is empty ''because'' they want to do something involving the files therein, etc.  Look to the larger question.  For example, one of these [[UsingFind|find-based examples]] may be an appropriate solution:

{{{#!highlight bash
# Bourne / POSIX
find "$somedir" -type f -exec echo Found unexpected file {} \;
find "$somedir" -prune -empty -exec printf '%s is empty.\n' {} \;  # GNU/BSD
find "$somedir" -type d -empty -exec cp /my/configfile {} \;   # GNU/BSD
}}}

Most commonly, all that's really needed is something like this:

{{{#!highlight bash
# Bourne / POSIX
for f in ./*.mpg; do
    test -f "$f" || continue
    mympgviewer "$f"
done
}}}

In other words, the person asking the question may have ''thought'' an explicit empty-directory test was needed to avoid an error message like `mympgviewer: ./*.mpg: No such file or directory` when in fact no such test is required.

Support for a nullglob-like feature is inconsistent. In ksh93 it can be done on a per-pattern basis by prefixing with ~(N)<<FootNote(From: [[http://permalink.gmane.org/gmane.comp.standards.posix.austin.general/2058]], which contains some good discussion.)>>:

{{{#!highlight bash
# ksh93
for f in ~(N)*; do
    ....
done
}}}
----
CategoryShell