bash if -a vs -e option


Both about -a and -e options in Bash documentation is said:

-a file
    True if file exists.
-e file
    True if file exists. 

Trying to get what the difference is I ran the following script:


if [ -e ${resin_dir} ] ; then
    echo "-e ";

if [ ! -e ${resin_dir} ] ; then
    echo "! -e";

if [ -a ${resin_dir} ] ; then
    echo "-a";

if [ ! -a ${resin_dir} ] ; then
    echo "! -a";

/Test/Resin_wheleph/Results exists and is a directory. And this is what I get:

! -a

which seems to be a little strange (notice -a and ! -a). But when I use double brackets (e. g. if [[ -e ${resin_dir} ]]) in the similar script it gives reasonable output:



  1. What is a difference between -a and -e options?
  2. Why -a produces a strange result when used inside single brackets?
7/2/2018 10:37:10 AM

Accepted Answer

I researched, and this is quite hairy:

-a is deprecated, thus isn't listed in the manpage for /usr/bin/test anymore, but still in the one for bash. Use -e . For single '[', the bash builtin behaves the same as the test bash builtin, which behaves the same as /usr/bin/[ and /usr/bin/test (the one is a symlink to the other). Note the effect of -a depends on its position: If it's at the start, it means file exists. If it's in the middle of two expressions, it means logical and.

[ ! -a /path ] && echo exists doesn't work, as the bash manual points out that -a is considered a binary operator there, and so the above isn't parsed as a negate -a .. but as a if '!' and '/path' is true (non-empty). Thus, your script always outputs "-a" (which actually tests for files), and "! -a" which actually is a binary and here.

For [[, -a isn't used as a binary and anymore (&& is used there), so its unique purpose is to check for a file there (although being deprecated). So, negation actually does what you expect.

11/26/2008 5:13:43 PM

The '-a' option to the test operator has one meaning as a unary operator and another as a binary operator. As a binary operator, it is the 'and' connective (and '-o' is the 'or' connective). As a unary operator, it apparently tests for a file's existence.

The autoconf system advises you to avoid using '-a' because it causes confusion; now I see why. Indeed, in portable shell programming, it is best to combine the conditions with '&&' or '||'.

I think @litb is on the right track. When you have '! -a ${resin_dir}', Bash may be interpreting it as "is the string '!' non-empty and is the string in '${resin_dir}' non-empty, to which the answer is yes. The Korn shell has a different view on this, and the Bourne shell yet another view - so stay away from '-a'.

On Solaris 10:

$ bash -c 'x=""; if [ ! -a "$x" ] ; then echo OK ; else echo Bad; fi'
$ ksh -c 'x=""; if [ ! -a "$x" ] ; then echo OK ; else echo Bad; fi'
$ sh -c 'x=""; if [ ! -a "$x" ] ; then echo OK ; else echo Bad; fi'
sh: test: argument expected

Licensed under: CC-BY-SA with attribution
Not affiliated with: Stack Overflow