|
7.3. Comparison operators (binary)integer comparison - -eq
is equal to if [ "$a" -eq "$b" ] - -ne
is not equal to if [ "$a" -ne "$b" ] - -gt
is greater than if [ "$a" -gt "$b" ] - -ge
is greater than or equal to if [ "$a" -ge "$b" ] - -lt
is less than 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" ] - ==
is equal to if [ "$a" == "$b" ] This is a synonym for =. [[ $a == z* ]] # true if $a starts with an "z" (pattern matching)
[[ $a == "z*" ]] # true if $a is equal to z*
[ $a == z* ] # file globbing and word splitting take place
[ "$a" == "z*" ] # true if $a is equal to z*
# Thanks, S.C. |
- !=
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. See Example 26-11 for an application of this
comparison operator. - -z
string is "null", that is, has zero length - -n
string is not "null".  | The -n test absolutely
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.
|
Example 7-5. Arithmetic and string comparisons #!/bin/bash
a=4
b=5
# Here "a" and "b" can be treated either as integers or strings.
# There is some blurring between the arithmetic and string comparisons,
#+ since Bash variables are not strongly typed.
# Bash permits integer operations and comparisons on variables
#+ whose value consists of all-integer characters.
# Caution advised.
echo
if [ "$a" -ne "$b" ]
then
echo "$a is not equal to $b"
echo "(arithmetic comparison)"
fi
echo
if [ "$a" != "$b" ]
then
echo "$a is not equal to $b."
echo "(string comparison)"
# "4" != "5"
# ASCII 52 != ASCII 53
fi
# In this particular instance, both "-ne" and "!=" work.
echo
exit 0 |
Example 7-6. 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
# Lets 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 ("$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 naked.
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 naked.
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". |
Example 7-7. zmost #!/bin/bash
#View gzipped files with 'most'
NOARGS=65
NOTFOUND=66
NOTGZIP=67
if [ $# -eq 0 ] # same effect as: if [ -z "$1" ]
# $1 can exist, but be empty: zmost "" arg2 arg3
then
echo "Usage: `basename $0` filename" >&2
# Error message to stderr.
exit $NOARGS
# Returns 65 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 $NOTFOUND
fi
if [ ${filename##*.} != "gz" ]
# Using bracket in variable substitution.
then
echo "File $1 is not a gzipped file!"
exit $NOTGZIP
fi
zcat $1 | most
# Uses the file viewer 'most' (similar to 'less').
# Later versions of 'most' have file decompression capabilities.
# May substitute 'more' or 'less', if desired.
exit $? # Script returns exit status of pipe.
# Actually "exit $?" 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 are
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 [ "$exp1" -a "$exp2" ] |
Refer to Example 8-3 and Example 26-16
to see compound comparison operators in action. |
|
jamesthornton.com>