Shell cast operators according to the operation used. There are two types of operators available

Integer comparison operators

String comparison operators

In the above two comparisons do exactly the same thing, but the first uses arithmetic comparison operators, while the second uses string comparison operators.

Quoting caveats

Most of the time, while you can omit the use of double quotes surrounding strings and string variables, it's not a good idea. Why? Because your code will work perfectly, unless an environment variable happens to have a space or a tab in it, in which case bash will get confused. Here's an example of a fouled-up comparison:

In the above example, if myvar equals "foo", the code will work as expected and not print anything. However, if myvar equals "foo bar oni", the code will fail with the following error:

In this case, the spaces in "$myvar" (which equals "foo bar oni") end up confusing bash. After bash expands "$myvar", it ends up with the following comparison:

Because the environment variable wasn't placed inside double quotes, bash thinks that you stuffed too many arguments in-between the square brackets. You can easily eliminate this problem by surrounding the string arguments with double-quotes. Remember, if you get into the habit of surrounding all string arguments and environment variables with double-quotes, you'll eliminate many similar programming errors. Here's how the "foo bar oni" comparison should have been written:

More quoting specifics

If you want your environment variables to be expanded, you must enclose them in double quotes, rather than single quotes. Single quotes disable variable (as well as history) expansion.

Shell arithmetic

Before looking at a second type of looping construct, it's a good idea to become familiar with performing shell arithmetic. Yes, it's true: You can perform simple integer math using shell constructs. Simply enclose the particular arithmetic expression between a "$((" and a "))", and bash will evaluate the expression. Here are some examples:

Compound comparison

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

Notes

As S.C. points out, in a compound test, even quoting the string variable might not suffice. [ -n "$string" -o "$a" = "$b" ] may cause an error with some versions of Bash if $string is empty. The safe way is to append an extra character to possibly empty variables, [ "x$string" != x -o "x$a" = "x$b" ] (the "x's" cancel out).

Old News ;-)

freshmeat.net Project details for Advanced Bash Scripting Guide by M. Leo Cooper

Linux tip Bash test and comparison functions

*Table 1. Some common file tests*
Operator	Characteristic
-d	Directory
-e	Exists (also -a)
-f	Regular file
-h	Symbolic link (also -L)
-p	Named pipe
-r	Readable by you
-s	Not empty
-S	Socket
-w	Writable by you
-N	Has been modified since last being read

*Table 2. Testing pairs of files*
Operator	True if
-nt	Test if file1 is newer than file 2. The modification date is used for this and the next comparison.
-ot	Test if file1 is older than file 2.
-ef	Test if file1 is a hard link to file2.

List Constructs

The "and list" and "or list" constructs provide a means of processing a number of commands consecutively. These can effectively replace complex nested if/then or even case statements. Note that the exit status of an "and list" or an "or list" is the exit status of the last command executed.

and list

   1 command-1 && command-2 && command-3 && ... command-n

Each command executes in turn provided that the previous command has given a return value of true. At the first false return, the command chain terminates (the first command returning false is the last one to execute).

Example 3-87. Using an "and list" to test for command-line arguments

   1 #!/bin/bash
   2 
   3 # "and list"
   4 
   5 if [ ! -z $1 ] && echo "Argument #1 = $1" && [ ! -z $2 ] && echo "Argument #2 = $2"
   6 then
   7   echo "At least 2 arguments to script."
   8   # All the chained commands return true.
   9 else
  10   echo "Less than 2 arguments to script."
  11   # At least one of the chained commands returns false.
  12 fi  
  13 # Note that "if [ ! -z $1 ]" works, but its supposed equivalent,
  14 # "if [ -n $1 ]" does not. This is a bug, not a feature.
  15 
  16 
  17 # This accomplishes the same thing, coded using "pure" if/then statements.
  18 if [ ! -z $1 ]
  19 then
  20   echo "Argument #1 = $1"
  21 fi
  22 if [ ! -z $2 ]
  23 then
  24   echo "Argument #2 = $2"
  25   echo "At least 2 arguments to script."
  26 else
  27   echo "Less than 2 arguments to script."
  28 fi
  29 # It's longer and less elegant than using an "and list".
  30 
  31 
  32 exit 0

or list

   1 command-1 || command-2 || command-3 || ... command-n

Each command executes in turn for as long as the previous command returns false. At the first true return, the command chain terminates (the first command returning true is the last one to execute). This is obviously the inverse of the "and list".

Example 3-88. Using "or lists" in combination with an "and list"

   1 #!/bin/bash
   2 
   3 # "Delete", not-so-cunning file deletion utility.
   4 # Usage: delete filename
   5 
   6 if [ -z $1 ]
   7 then
   8   file=nothing
   9 else
  10   file=$1
  11 fi  
  12 # Fetch file name (or "nothing") for deletion message.
  13 
  14 
  15 [ ! -f $1 ] && echo "$1 not found. Can't delete a nonexistent file."
  16 # AND LIST, to give error message if file not present.
  17 
  18 [ ! -f $1 ] || ( rm -f $1; echo "$file deleted." )
  19 # OR LIST, to delete file if present.
  20 # ( command1 ; command2 ) is, in effect, an AND LIST variant.
  21 
  22 # Note logic inversion above.
  23 # AND LIST executes on true, OR LIST on false.
  24 
  25 [ ! -z $1 ] ||  echo "Usage: `basename $0` filename"
  26 # OR LIST, to give error message if no command line arg (file name).
  27 
  28 exit 0

Clever combinations of "and" and "or" lists are possible, but the logic may easily become convoluted and require extensive debugging.

News	See also	Recommended Links	Advanced navigation	Pipes in Loops
Arithmetic expressions	Comparison operators	Loops in Shell	Shell History	Etc

Shell Conditional operators