bash if not multiple conditions without subshell?

Question

I want to combine multiple conditions in a shell if statement, and negate the combination. I have the following working code for a simple combination of conditions:

if [ -f file1 ] && [ -f file2 ] && [ -f file3 ] ; then
  # do stuff with the files
fi

This works fine. If I want to negate it, I can use the following working code:

if ! ( [ -f file1 ] && [ -f file2 ] && [ -f file3 ] ) ; then
  echo "Error: You done goofed."
  exit 1
fi
# do stuff with the files

This also works as expected. However, it occurs to me that I don't know what the parentheses are actually doing there. I want to use them just for grouping, but is it actually spawning a subshell? (How can I tell?) If so, is there a way to group the conditions without spawning a subshell?

Answer 1

You need to use { list;} instead of (list):

if ! { [ -f file1 ] && [ -f file2 ] && [ -f file3 ]; }; then
  : do something
fi

Both of them are Grouping Commands, but { list;} executes commands in current shell environment.

Note that, the ; in { list;} is needed to delimit the list from } reverse word, you can use other delimiter as well. The space (or other delimiter) after { is also required.

Answer 2

To portably negate a complex conditional in shell, you must either apply De Morgan's law and push the negation all the way down inside the [ calls...

if [ ! -f file1 ] || [ ! -f file2 ] || [ ! -f file3 ]
then
    # do stuff
fi

... or you must use then :; else ...

if [ -f file1 ] && [ -f file2 ] && [ -f file3 ]
then :
else
  # do stuff
fi

if ! command is not portably available and neither is [[.

If you don't need total portability, don't write a shell script. You're actually more likely to find /usr/bin/perl on a randomly selected Unix than you are bash.

Answer 3

You could use entirely the test functionality to achieve what you want. From the man page of test:

 ! expression  True if expression is false.
 expression1 -a expression2
               True if both expression1 and expression2 are true.
 expression1 -o expression2
               True if either expression1 or expression2 are true.
 (expression)  True if expression is true.

So your condition could look like:

if [ -f file1 -a -f file2 -a -f file3 ] ; then
    # do stuff with the files
fi

For negating use escaped parentheses:

if [ ! \( -f file1 -a -f file2 -a -f file3 \) ] ; then
    echo "Error: You done goofed."
    exit 1
fi
# do stuff with the files

Answer 4

others have noted the { compound command ;} grouping, but if you are performing identical tests on a set you might like to use a different kind:

if  ! for f in file1 file2 file3
      do  [ -f "$f" ] || ! break
      done
then  : do stuff
fi

...as is elsewhere demonstrated with { :;}, there is no difficulty involved with nesting compound commands...

Note that the above (typically) tests for regular files. If you're looking only for existing, readable files which are not directories:

if  ! for f in file1 file2 file3
      do  [ ! -d "$f" ] && 
          [   -r "$f" ] || ! break
      done
then  : do stuff
fi

If you don't care whether they are directories or not:

if  ! command <file1 <file2 <file3
then  : do stuff
fi

...works for any readable, accessible file, but will likely hang for fifos w/out writers.

Answer 5

This is not a full-on answer to your main question, but I noticed that you mention compound testing (readable file) in a comment; e.g.,

if [ -f file1 ] && [ -r file1 ] && [ -f file2 ] && [ -r file2 ] && [ -f file3 ] && [ -r file3 ]

You can consolidate this a little by defining a shell function; e.g.,

readable_file()
{
    [ -f "$1" ]  &&  [ -r "$1" ]
}

Add error handling to (e.g., [ $# = 1 ]) to taste.  The first if statement, above, can now be condensed to

if readable_file file1  &&  readable_file file2  &&  readable_file file3

and you can shorten this even further by shortening the name of the function.  Likewise, you could define not_readable_file() (or nrf for short) and include the negation in the function.

Answer 6

Why not this?

[[ ! ( -f file1 && -f file2 && -f file3 ) ]]

Numerical example:

i=1
j=-1
[[ ! ( i -eq 1 && j -eq -1 ) ]]
echo $?

Output:

1

In the other three combinations of i and j, the output is:

0

Answer 7

You can negate inside the brace tests also, so to reuse your original code:

# Using || (or)
if [[ ! -f file1 || ! -f file2 || ! -f file3 ]]; then
    # Do stuff with the files
fi

# Using && (and)
if [[ ! ( -f file1 && -f file2 && -f file3 ) ]]; then
    # Do stuff with the files
fi

Answer 8

I want to use them just for grouping, but is it actually spawning a subshell? (How can I tell?)

Yes, the commands within the (...) are run in a subshell.

To test whether you're in a subshell you can compare the PID of your current shell with the PID of the interactive shell.

echo $BASHPID; (echo $BASHPID); 

Example output, demonstrating that parentheses spawn a subshell and curly braces do not:

$ echo $BASHPID; (echo $BASHPID); { echo $BASHPID;}
50827
50843
50827
$