Other comparison operators

A binary comparison operator compares two variables or quantities. Note that integer and string comparison use a different set of operators.

Integer comparison

-eq

Is equal to

if [ "$a" -eq "$b" ]

-ne

Is no equal to

if [ "$a" -ne "$b" ]

-gt

Is greater than to

if [ "$a" -gt "$b" ]

-ge

Is greater than or equal to

if [ "$a" -ge "$b" ]

-lt

Is less than to

if [ "$a" -lt "$b" ]

-le

Is less than or equal to

if [ "$a" -le "$b" ]

<

Is less than (within double parentheses)

(( "$a" < "$b" ))

<=

Is less than or equal to (within double parentheses)

(( "$a" <= "$b" ))

>

Is greater than (within double parentheses)

(( "$a" > "$b" ))

>=

Is greater than or equal to (within double parentheses)

(( "$a" >= "$b" ))

String comparison

=

Is equal to

if [ "$a" = "$b" ]

Caution: Note the whitespace framing the =!

if [ "$a"="$b" ] is not equivalent to the above.

==

Is equal to

if [ "$a" == "$b" ]

This is a synonym for =.

Note: The == comparison operator behaves differently within a double-brackets test than within single brackets.

[[ $a == z* ]]   # True if $a starts with an "z" (pattern matching).
[[ $a == "z*" ]] # True if $a is equal to z* (literal matching).
[ $a == z* ]     # File globbing and word splitting take place.
[ "$a" == "z*" ] # True if $a is equal to z* (literal matching).
# Thanks, Stéphane Chazelas

!=

Is not equal to

if [ "$a" != "$b" ]

This operator uses pattern matching within a [[ ... ]] construct.

<

Is less than in ASCII alphabetical order

if [[ "$a" < "$b" ]]
if [ "$a" \< "$b" ]

Note that the < needs to be escaped within a [ ] construct.

>

Is greater than in ASCII alphabetical order

if [[ "$a" > "$b" ]]
if [ "$a" \> "$b" ]

Note that the > needs to be escaped within a [ ] construct.

TODO: See example for an application of this operator

-z

String is null, that is, has zero length

String=''   # Zero-length ("null") string variable.
if [ -z "$String" ]
then
  echo "\$String is null."
else
  echo "\$String is NOT null."
fi     # $String is null.

-n

String is not null

Caution: The -n test requires that the string be quoted within the test brackets. Using an unquoted string with ! -z, or even just the unquoted string alone within test brackets (see Example 7-6) normally works, however, this is an unsafe practice. Always quote a tested string. [1]

Testing whether a string is null

#!/bin/bash
#  str-test.sh: Testing null strings and unquoted strings,
#+ but not strings and sealing wax, not to mention cabbages and kings . . .
# Using   if [ ... ]
# If a string has not been initialized, it has no defined value.
# This state is called "null" (not the same as zero!).
if [ -n $string1 ]    # string1 has not been declared or initialized.
then
  echo "String \"string1\" is not null."
else
  echo "String \"string1\" is null."
fi                    # Wrong result.
# Shows $string1 as not null, although it was not initialized.
echo
# Let's try it again.
if [ -n "$string1" ]  # This time, $string1 is quoted.
then
  echo "String \"string1\" is not null."
else
  echo "String \"string1\" is null."
fi                    # Quote strings within test brackets!
echo
if [ $string1 ]       # This time, $string1 stands naked.
then
  echo "String \"string1\" is not null."
else
  echo "String \"string1\" is null."
fi                    # This works fine.
# The [ ... ] test operator alone detects whether the string is null.
# However it is good practice to quote it (if [ "$string1" ]).
#
# As Stephane Chazelas points out,
#    if [ $string1 ]    has one argument, "]"
#    if [ "$string1" ]  has two arguments, the empty "$string1" and "]"
echo
string1=initialized
if [ $string1 ]       # Again, $string1 stands unquoted.
then
  echo "String \"string1\" is not null."
else
  echo "String \"string1\" is null."
fi                    # Again, gives correct result.
# Still, it is better to quote it ("$string1"), because . . .
string1="a = b"
if [ $string1 ]       # Again, $string1 stands unquoted.
then
  echo "String \"string1\" is not null."
else
  echo "String \"string1\" is null."
fi                    # Not quoting "$string1" now gives wrong result!
exit 0   # Thank you, also, Florian Wisser, for the "heads-up".

zmore

#!/bin/bash
# zmore
# View gzipped files with 'more' filter.
E_NOARGS=85
E_NOTFOUND=86
E_NOTGZIP=87
if [ $# -eq 0 ] # same effect as:  if [ -z "$1" ]
# $1 can exist, but be empty:  zmore "" arg2 arg3
then
  echo "Usage: `basename $0` filename" >&2
  # Error message to stderr.
  exit $E_NOARGS
  # Returns 85 as exit status of script (error code).
fi
filename=$1
if [ ! -f "$filename" ]   # Quoting $filename allows for possible spaces.
then
  echo "File $filename not found!" >&2   # Error message to stderr.
  exit $E_NOTFOUND
fi
if [ ${filename##*.} != "gz" ]
# Using bracket in variable substitution.
then
  echo "File $1 is not a gzipped file!"
  exit $E_NOTGZIP
fi
zcat $1 | more
# Uses the 'more' filter.
# May substitute 'less' if desired.
exit $?   # Script returns exit status of pipe.
#  Actually "exit $?" is unnecessary, as the script will, in any case,
#+ return the exit status of the last command executed.

Compound Comparison

-a

Logical and

exp1 -a exp2 returns true if both exp1 and exp2 are true.

-o

Logical or

exp1 -o exp2 returns true if either exp1 or exp2 is true.

These are similar to the Bash comparison operators && and ||, used within double brackets.

[[ condition1 && condition2 ]]

The -o and -a operators work with the test command or occur within single test brackets.

if [ "$expr1" -a "$expr2" ]
then
  echo "Both expr1 and expr2 are true."
else
  echo "Either expr1 or expr2 is false."
fi

Caution: But, as rihad points out:

[ 1 -eq 1 ] && [ -n "`echo true 1>&2`" ]   # true
[ 1 -eq 2 ] && [ -n "`echo true 1>&2`" ]   # (no output)
# ^^^^^^^ False condition. So far, everything as expected.
# However ...
[ 1 -eq 2 -a -n "`echo true 1>&2`" ]       # true
# ^^^^^^^ False condition. So, why "true" output?
# Is it because both condition clauses within brackets evaluate?
[[ 1 -eq 2 && -n "`echo true 1>&2`" ]]     # (no output)
# No, that's not it.
# Apparently && and || "short-circuit" while -a and -o do not.

TODO: Refer to Example 8-3, Example 27-17, and Example A-29 to see compound comparison operators in action.