When using test or [ to evaluate conditional expressions with logical NOT !, should the exclamation point go inside or outside the brackets?

Question

When using bash test or [ builtin commands to evaluate conditional expressions with logical NOT !, should the exclamation point go inside or outside the brackets? Does it matter?

Here is a trivial MRE.

$ var=1
$ if [ $var -gt 0 ]; then echo "evaluated to true"; else echo "evaluated to false";  fi
evaluated to true
$ if ! [ $var -gt 0 ]; then echo "evaluated to true"; else echo "evaluated to false";  fi
evaluated to false
$ if [ ! $var -gt 0 ]; then echo "evaluated to true"; else echo "evaluated to false";  fi

Answer 1

Yes, it does matter.

If you put the ! outside the [ ... ], then any error will be ignored:

var=nono

if ! [ "$var" -gt 0 ]; then echo YES; fi
bash: [: 0.1: integer expression expected
YES

if [ ! "$var" -gt 0 ]; then echo YES; fi
bash: [: 0.1: integer expression expected

That's because if ! command; then ... will match when the exit status of command is non-zero, and a [ expr ] command will have a non-zero exit status both in the case of an error and in the case where expr has evaluated to false.

Only in ksh (NOT in bash) are the two kind of similar, because in ksh a non-numeric variable will be treated as 0 in that context, instead of being an error.

Answer 2

! [ "$var" -gt 0 ] vs. [ ! "$var" -gt 0 ] shouldn't matter with current shells and utilities as long as there are no errors.

---

But note that you wrote if ! [ $var -gt 0 ] and if [ ! $var -gt 0 ] without the quotes around $var and that does matter!

That would break if $var was empty or contained whitespace. You'd get e.g. if ! [ -gt 0 ] where the [ test would print an error message and return a falsy exit code of 2. It would then be inverted by !, and the condition as whole would be true!

$ var=
$ if ! [ $var -gt 0 ]; then echo yes; fi
bash: [: -gt: unary operator expected
yes

In that particular context, [ ! $var -gt 0 ] could be seen as safer, as the falsy error return would stay falsy, and the branch not taken. Here, the immediate problem is in the lack of quotes, though, and that's easy to fix.

About quotes, see: When is double-quoting necessary?

---

However, even apart from the quoting issue, non-numeric values in $var would also give an error from [ and make the condition false. Because of that, you should test that the inputs are valid beforehand or otherwise deal with the possibility. In some cases, the proper action in case of an error could be to take the branch, e.g. if it contained an error exit. Sadly, the shell doesn't really have a good way of detecting errors, as there are no exceptions or such. To tell an error from a false result, the raw value in $? would need to be saved and consulted.

Or the test could be written so that the error case coincides with an appropriate result. For example, here the test is written with an extra negation instead of [ "$1" -le 0 ], but this has the advantage that an invalid input will trigger the error exit. This only works with the ! outside [.

$ cat foo.sh
#!/bin/bash

if ! [ "$1" -gt 0 ]; then
    echo "invalid input '$1'"
    exit 1
fi
echo "doing work on '$1'"

$ bash foo.sh
foo.sh: line 3: [: : integer expression expected
invalid input ''

The variations of values of the variable and the different tests in a matrix:

   test   \   $n    |   '0'       '1'      'x'     
 -------------------+------------------------------------            
  [   "$n" -le 0 ]  |  truthy    falsy    falsy  (w/error)
  [ ! "$n" -gt 0 ]  |  truthy    falsy    falsy  (w/error)
! [   "$n" -gt 0 ]  |  truthy    falsy    truthy (w/error)

---

Perhaps somewhat relatedly, in times of yore, versions of [ were known to get confused when the operands within a test looked like operators. E.g. with something like [ ! = x ] the ! could be taken as a negation and the expression as whole could not be parsed. One might fear that putting the ! inside [ might compound that issue, but I don't know if that ever would have happened in practice. In any case, POSIX-conforming versions of [ should be safe from that, at least as long as you don't use -a and -o.

See: What's the purpose of adding a prefix on both sides of a shell variable comparison to a string literal?, especially Stéphane's great answer there (from which I nicked the [ ! = x ] example).

Answer 3

It only matters if you care about what's evaluating the !, which you may do if you take failures in the [ utility into account (e.g. $var not actually being an integer, in which case the [ utility would fail and its exit status would be non-zero, i.e. not because the test evaluated to false but because the utility failed to perform the test).

In if [ ! "$var" -gt 0 ]; then ...; fi, the ! is an argument to [ and will therefore be evaluated by the [ utility, making it internally negate the sense of the test before terminating with the appropriate exit status. (If $var is not an integer, the test would fail, and the branch would not be taken.)

In if ! [ "$var" -gt 0 ]; then ...; fi, the shell will negate (well, toggle between 0 and non-zero) the exit status of the [ utility before using it for the if statement. (If $var is not an integer, the test would fail, the shell would negate the non-zero exit status and interpret it as true, and the branch would be taken.)

For this simple test, I would probably rewrite the test as [ "$var" -le 0 ] for ease of reading and understanding the code, and, if need be, employ validation of $var as an integer.