With Bash and Dash, you can check for an empty directory using just the shell (ignore dotfiles to keep things simple):

set *
if [ -e "$1" ]
  echo 'not empty'
  echo 'empty'

However I recently learned that Zsh fails spectacularly in this case:

% set *
zsh: no matches found: *

% echo "$? $#"
1 0

So not only does the set command fail, but it doesn't even set $@. I suppose I could test if $# is 0, but it appears that Zsh even stops execution:

% { set *; echo 2; }
zsh: no matches found: *

Compare with Bash and Dash:

$ { set *; echo 2; }

Can this be done in a way that works in bash, dash and zsh?


5 Answers 5


There are several problems with that

set *
if [ -e "$1" ]
  echo 'not empty'
  echo 'empty'


  • if the nullglob option (from zsh but now supported by most other shells) is enabled, set * becomes set which lists all the shell variables (and functions in some shells)
  • if the first non-hidden file has a name that starts with - or +, it will be treated as an option by set. Those two issues can be fixed by using set -- * instead.
  • * expands only non-hidden files, so it's not a test whether the directory is empty or not but whether it contains non-hidden files or not. With some shells, you can use a dotglob or globdot option or play with a FIGNORE special variable depending on the shell to work around that.
  • [ -e "$1" ] tests whether a stat() system call succeeds or not. If the first file is a symlink to an inaccessible location, that will return false. You shouldn't need to stat() (not even lstat()) any file to know whether a directory is empty or not, only check that it has some content.
  • * expansion involves opening the current directory, retrieving all the entries, storing all the non-hidden one and sorting them, which is also quite inefficient.

The most efficient way to check if a directory is non-empty (has any entry other than . and ..) in zsh is with the F glob qualifier (F for full, here meaning non-empty):

if [ .(NF) ]; then
  print . is not empty
  print "it's empty or I can't read it"

N is the nullglob glob qualifier. So .(NF) expands to . if . is full and nothing otherwise.

After the lstat() on the directory, if zsh finds it has a link-count greater than 2, then that means it has at least one subdirectory so is not empty, so we don't even need to open that directory (that also means, in that case we can tell that the directory is non-empty even if we don't have read access to it). Otherwise, zsh opens the directory, reads its content and stops at the first entry that is neither . nor .. without having to read, store nor sort everything.

With POSIX shells (zsh only behaves (more) POSIXly in sh emulation), it is very awkward to check that a directory is non-empty with globs only.

One way is with:

set .[!.]* '.[!.]'[*] .[.]?* [*] *
if [ "$#$1$2$3$4$5" = '5.[!.]*.[!.][*].[.]?*[*]*' ]; then
  echo "empty or can't read"
  echo not empty

(assuming no glob-related option is changed from the default (POSIX only specifies noglob) and that the GLOBIGNORE (for bash) and FIGNORE (for ksh) variables are not set, and that (for yash) none of the file names contain sequences of bytes not forming valid characters).

The idea is that in POSIX shells, when a glob doesn't match, it is left unexpanded (a misfeature introduced by the Bourne shell in the late 70s). So with set -- *, if we get $1 == *, we don't know whether it was because there was no match or whether there was a file called *.

Your (flawed) approach to work around that was to use [ -e "$1" ]. Here instead, we use set -- [*] *. That allows to disambiguate the two cases, because if there is no file, the above will stay [*] *, and if there is a file called *, that becomes * *. We do something similar for hidden files. That is a bit awkward because of yet another misfeature of the Bourne shell (also fixed by zsh, the Forsyth shell, pdksh and fish) whereby the expansion of .* does include the special (pseudo-)entries . and .. when reported by readdir().

So to make it work in all those shells, you could do:

  if [ -n "$ZSH_VERSION" ]; then
    eval '! [ .(NF) ]'
    set .[!.]* '.[!.]'[*] .[.]?* [*] *
    [ "$#$1$2$3$4$5" = '5.[!.]*.[!.][*].[.]?*[*]*' ]

In any case, the syntax of zsh by default is not compatible with the POSIX sh syntax as it has fixed most of the major issues in the Bourne shell (well before POSIX.2 was first published) in a non-backward compatible way, including that * left unexpanded when there's no match (pre-Bourne shells didn't have that issue, csh, tcsh and fish don't either), and .* including . and .. but several others like split+glob performed upon parameter or arithmetic expansion, so you can't expect code written in the POSIX sh to always work in zsh unless you turn on sh emulation.

That sh emulation is especially there so you can use POSIX code in zsh.

If you want to source a file written in POSIX sh inside zsh, you can do:

emulate sh -c 'source that-file'

Then that file will be evaluated in sh emulation and any function declared within will retain that emulation mode.

  • Note you need to use [ path(NF) ]; [[ path(NF) ]] doesn't work. Oct 2, 2022 at 20:27

While zsh's default behaviour is to give an error, this is controlled by the nomatch option. You can unset the option to leave the * in place the way that bash and dash do:

setopt -o nonomatch

While that command won't work in either of the others, you can just ignore that:

setopt -o nonomatch 2>/dev/null || true ; set *

This runs setopt on zsh, and suppresses the error output (2>/dev/null) and return code (|| true) of the failed command on the others.

As written it's problematic if there is a file, for example, -e: then you will run set -e and change the shell options to terminate whenever a command fails; there are worse outcomes if you're creative. set -- * will be safer and prevent the option changes.


Zsh's syntax is not compatible with sh. It's close enough to look like sh, but not close enough that you can take sh code and run it unchanged.

If you want to run sh code in zsh, for example because you have an sh function or snippet written for sh that you want to use in a zsh script, you can use the emulate builtin. For example, to source a file written for sh in a zsh script:

emulate sh -c 'source /path/to/file.sh'

To write a function or script in sh syntax and make it possible to run it in zsh, put this near the beginning:

emulate -L sh 2>/dev/null || true

In sh syntax, zsh supports all POSIX constructs (it's about as POSIX compliant as bash --posix or ksh93 or mksh). It also supports some ksh and bash extensions such as arrays (0-indexed in ksh, in bash and under emulate sh, but 1-indexed in native zsh) and [[ … ]]. If you want POSIX sh plus ksh globs, use emulate … ksh … instead of emulate … sh …, and add if [[ -n $BASH ]]; then shopt -s extglob; fi for the sake of bash (note that this is not local to the script/function).

The native zsh way to enumerate all the entries in a directory except . and .. is

set -- *(DN)

This uses the glob qualifiers D to include dot files and N to produce an empty list if there are no matches.

The portable sh way to enumerate all the entries in a directory except . and .. is a lot more complicated. You need to list dot files, and if you're listing files in the current directory or in a path that isn't guaranteed to be absolute you need take care in case there is a file name that begins with a dash. Here's one way to do it, by using the patterns ..?* .[!.]* * to list all files except . and .. and removing unexpanded patterns.

set -- ..?*
if [ "$#" -eq 1 ] && ! [ -e "$1" ] && ! [ -L "$1" ]; then shift; fi
set -- .[!.]* "$@"
if [ "$#" -eq 1 ] && ! [ -e "$1" ] && ! [ -L "$1" ]; then shift; fi
set -- * "$@"
if [ "$#" -eq 1 ] && ! [ -e "$1" ] && ! [ -L "$1" ]; then shift; fi

If all you want to do is to test whether a directory is empty, there's a much easier way.

if ls -A /path/to/directory/ | grep -q '^'; then
  echo "/path/to/directory is not empty"
  echo "/path/to/directory is empty"
  • shorter if ls -A | read q; then echo not empty; else echo empty; fi
    – user327359
    Jan 13, 2019 at 14:25
  • @user327359, that could fail if the pipefail option is on or if all the filenames in the directory end in backslash. In any case using ls -A means reading the directory fully and sorting its entries, so is less efficient than using zsh's F glob qualifier. Mar 19, 2021 at 7:01

Most portable way would be via set and globstar for all POSIX-compliant shells. This has been shown in Gilles's answer on a related question. I've adapted the method slightly into a function:

rm -rf empty_dir/
mkdir empty_dir/
cd empty_dir/

    # https://stackoverflow.com/a/9911082/3701431
    if [ -n "$ZSH_VERSION" ]; then
        # https://unix.stackexchange.com/a/310553/85039
        setopt +o nomatch 

    set -- * .*
    echo "$@"
    for i; do
        [ "$i" = "." ] || [ "$i" = ".." ] && continue
        [ -e "$i" ] && echo "Not empty" && return 1
    echo "Empty" && return 0
touch  '*'

The big problem with zsh is that while ksh and bash behave in more or less consistent manner - that is when we do set * .* you will have 3 positional parameters * . .. in really empty directory - in zsh you will get * .* as positional parameters. Luckily at least for i ; do ... done to iterate over positional parameters works consistently. The rest is just iteration and check for existence of the filename, with . and .. skipped.

Try it online in ksh!

Try it online in zsh!

  • @Three I've adapted the answer to check for zsh. Unfortunatelly for us zsh decided to go the weird way instead of similar behavior to bash or other shells, since according to POSIX: "If the pattern does not match any pathnames, the returned number of matched paths is set to 0, and the contents of pglob->gl_pathv are implementation-defined." source Jan 7, 2019 at 2:25
  • turning nomatch everywhere risks breaking code that assumes the default (and very sensible) setting that sh and bash get wrong, so the change really should be localized only to this function
    – thrig
    Jan 7, 2019 at 3:02
  • @thrig Well, considering that so far others haven't found a way to make glob work without nomatch, that's the best we got. We can also toggle it back before function exits, of course. Or we could just abandon shell ways and just use something else, like find for instance. Jan 7, 2019 at 3:16
  • @Three I've revised the answer again. Probably this is the best I can do, as zsh seems to favor features instead of consistency. Hope this helps somewhat. Jan 7, 2019 at 3:18
  • 1
    The expansion of .* not including . and .. is what you generally want and was done in the public domain version of ksh before zsh (pdksh inherited it from the Forsyth shell on which it is based). In other shells whether . and .. is included depends on whether readdir() returns them or not which is not guaranteed. Jan 27, 2019 at 0:01

I'm not sure about the set * solution. How about this?


for i in "$dir"/*; do 
  if test ! "$i" = "$dir/*"; then
    echo "$i"

echo "$has_file"

Tested and this works well for zsh, bash, ash, ksh, bourne AKA heirloom

You must log in to answer this question.