The largest Interview Solution Library on the web


« Previous | 1 | 2 | 3 | Next »

Unix - Basic Operators


There are various operators supported by each shell. Our tutorial is based on default shell (Bourne) so we are going to cover all the important Bourne Shell operators in the tutorial.

There are following operators which we are going to discuss:
  • Arithmetic Operators.
  • Relational Operators.
  • Boolean Operators.
  • String Operators.
  • File Test Operators.
The Bourne shell didn't originally have any mechanism to perform simple arithmetic but it uses external programs, either awk or the must simpler program expr.

Here is simple example to add two numbers:

#!/bin/sh
val=`expr 2 + 2`
echo "Total value : $val"

This would produce following result:

Total value : 4

There are following points to note down:

  • There must be spaces between operators and expressions for example 2+2 is not correct, where as it should be written as 2 + 2.
  • Complete expression should be enclosed between ``, called inverted commas.
Arithmetic Operators:

There are following arithmetic operators supported by Bourne Shell.

Assume variable a holds 10 and variable b holds 20 then:
OperatorDescriptionExample
+Addition - Adds values on either side of the operator`expr $a + $b` will give 30
-Subtraction - Subtracts right hand operand from left hand operand`expr $a - $b` will give -10
*Multiplication - Multiplies values on either side of the operator`expr $a * $b` will give 200
/Division - Divides left hand operand by right hand operand`expr $b / $a` will give 2
%Modulus - Divides left hand operand by right hand operand and returns remainder`expr $b % $a` will give 0
=Assignment - Assign right operand in left operanda=$b would assign value of b into a
==Equality - Compares two numbers, if both are same then returns true.[ $a == $b ] would return false.
!=Not Equality - Compares two numbers, if both are different then returns true.[ $a != $b ] would return true.
It is very important to note here that all the conditional expressions would be put inside square braces with one spaces around them, for example [ $a == $b ] is correct where as [$a==$b] is incorrect.

All the arithmetical calculations are done using long integers.

Example:

Here is an example which uses all the arithmetic operators:

#!/bin/sh
a=10
b=20
val=`expr $a + $b`
echo "a + b : $val"
val=`expr $a - $b`
echo "a - b : $val"
val=`expr $a \* $b`
echo "a * b : $val"
val=`expr $b / $a`
echo "b / a : $val"
val=`expr $b % $a`
echo "b % a : $val"
if [ $a == $b ]
then
echo "a is equal to b"
fi
if [ $a != $b ]
then
echo "a is not equal to b"
fi

This would produce following result:

a + b : 30
a - b : -10
a * b : 200
b / a : 2
b % a : 0
a is not equal to b

There are following points to note down:
  • There must be spaces between operators and expressions for example 2+2 is not correct, where as it should be written as 2 + 2.
  • Complete expression should be enclosed between ``, called inverted commas.
  • You should use \ on the * symbol for multiplication.
  • if...then...fi statement is a decision making statement which has been explained in next chapter.
Relational Operators:

Bourne Shell supports following relational operators which are specific to numeric values. These operators would not work for string values unless their value is numeric.

For example, following operators would work to check a relation between 10 and 20 as well as in between "10" and "20" but not in between "ten" and "twenty".

Assume variable a holds 10 and variable b holds 20 then:
OperatorDescriptionExample
-eqChecks if the value of two operands are equal or not, if yes then condition becomes true.[ $a -eq $b ] is not true.
-neChecks if the value of two operands are equal or not, if values are not equal then condition becomes true.[ $a -ne $b ] is true.
-gtChecks if the value of left operand is greater than the value of right operand, if yes then condition becomes true.[ $a -gt $b ] is not true.
-ltChecks if the value of left operand is less than the value of right operand, if yes then condition becomes true.[ $a -lt $b ] is true.
-geChecks if the value of left operand is greater than or equal to the value of right operand, if yes then condition becomes true.[ $a -ge $b ] is not true.
-leChecks if the value of left operand is less than or equal to the value of right operand, if yes then condition becomes true.[ $a -le $b ] is true.
It is very important to note here that all the conditional expressions would be put inside square braces with one spaces around them, for example [ $a <= $b ] is correct where as [$a <= $b] is incorrect.

Example:

Here is an example which uses all the relational operators:

#!/bin/sh
a=10
b=20
if [ $a -eq $b ]
then
echo "$a -eq $b : a is equal to b"
else
echo "$a -eq $b: a is not equal to b"
fi
if [ $a -ne $b ]
then
echo "$a -ne $b: a is not equal to b"
else
echo "$a -ne $b : a is equal to b"
fi
if [ $a -gt $b ]
then
echo "$a -gt $b: a is greater than b"
else
echo "$a -gt $b: a is not greater than b" fi
if [ $a -lt $b ]
then
echo "$a -lt $b: a is less than b"
else
echo "$a -lt $b: a is not less than b"
fi
if [ $a -ge $b ]
then
echo "$a -ge $b: a is greater or equal to b"
else
echo "$a -ge $b: a is not greater or equal to b"
fi
if [ $a -le $b ]
then
echo "$a -le $b: a is less or equal to b"
else
echo "$a -le $b: a is not less or equal to b"
fi

This would produce following result:

10 -eq 20: a is not equal to b
10 -ne 20: a is not equal to b
10 -gt 20: a is not greater than b
10 -lt 20: a is less than b
10 -ge 20: a is not greater or equal to b
10 -le 20: a is less or equal to b

There are following points to note down:

  • There must be spaces between operators and expressions for example 2+2 is not correct, where as it should be written as 2 + 2.
  • if...then...else...fi statement is a decision making statement which has been explained in next chapter.
Boolean Operators:

There are following boolean operators supported by Bourne Shell.

Assume variable a holds 10 and variable b holds 20 then:
OperatorDescriptionExample
!This is logical negation. This inverts a true condition into false and vice versa.[ ! false ] is true.
-oThis is logical OR. If one of the operands is true then condition would be true.[ $a -lt 20 -o $b -gt 100 ] is true.
-aThis is logical AND. If both the operands are true then condition would be true otherwise it would be false.[ $a -lt 20 -a $b -gt 100 ] is false.
Example:

Here is an example which uses all the boolean operators:

#!/bin/sh
a=10
b=20
if [ $a != $b ]
then
echo "$a != $b : a is not equal to b"
else
echo "$a != $b: a is equal to b"
fi
if [ $a -lt 100 -a $b -gt 15 ]
then
echo "$a -lt 100 -a $b -gt 15 : returns true"
else
echo "$a -lt 100 -a $b -gt 15 : returns false"
fi
if [ $a -lt 100 -o $b -gt 100 ]
then
echo "$a -lt 100 -o $b -gt 100 : returns true"
else
echo "$a -lt 100 -o $b -gt 100 : returns false"
fi
if [ $a -lt 5 -o $b -gt 100 ]
then
echo "$a -lt 100 -o $b -gt 100 : returns true"
else
echo "$a -lt 100 -o $b -gt 100 : returns false"
fi

This would produce following result:

10 != 20 : a is not equal to b
10 -lt 100 -a 20 -gt 15 : returns true
10 -lt 100 -o 20 -gt 100 : returns true
10 -lt 5 -o 20 -gt 100 : returns false

There are following points to note down:
  • There must be spaces between operators and expressions for example 2+2 is not correct, where as it should be written as 2 + 2.
  • if...then...else...fi statement is a decision making statement which has been explained in next chapter.
String Operators:

There are following string operators supported by Bourne Shell.

Assume variable a holds "abc" and variable b holds "efg" then:
OperatorDescriptionExample
=Checks if the value of two operands are equal or not, if yes then condition becomes true.[ $a = $b ] is not true.
!=Checks if the value of two operands are equal or not, if values are not equal then condition becomes true.[ $a != $b ] is true.
-zChecks if the given string operand size is zero. If it is zero length then it returns true.[ -z $a ] is not true.
-nChecks if the given string operand size is non-zero. If it is non-zero length then it returns true.[ -z $a ] is not false.
StrCheck if str is not the empty string. If it is empty then it returns false.[ $a ] is not false.
Example:

Here is an example which uses all the string operators:

#!/bin/sh
a="abc"
b="efg"
if [ $a = $b ]
then
echo "$a = $b : a is equal to b"
else
echo "$a = $b: a is not equal to b"
fi
if [ $a != $b ]
then
echo "$a != $b : a is not equal to b"
else
echo "$a != $b: a is equal to b"
fi
if [ -z $a ]
then
echo "-z $a : string length is zero"
else
echo "-z $a : string length is not zero"
fi
if [ -n $a ]
then
echo "-n $a : string length is not zero"
else
echo "-n $a : string length is zero"
fi
if [ $a ]
then
echo "$a : string is not empty"
else
echo "$a : string is empty"
fi

This would produce following result:

abc = efg: a is not equal to b
abc != efg : a is not equal to b
-z abc : string length is not zero
-n abc : string length is not zero
abc : string is not empty

There are following points to note down:
  • There must be spaces between operators and expressions for example 2+2 is not correct, where as it should be written as 2 + 2.
  • if...then...else...fi statement is a decision making statement which has been explained in next chapter.
File Test Operators:

There are following operators to test various properties associated with a Unix file.

Assume a variable file holds an existing file name "test" whose size is 100 bytes and has read, write and execute permission on:
OperatorDescriptionExample
-b fileChecks if file is a block special file if yes then condition becomes true.[ -b $file ] is false.
-c fileChecks if file is a character special file if yes then condition becomes true.[ -b $file ] is false.
-d fileCheck if file is a directory if yes then condition becomes true.[ -d $file ] is not true.
-f fileCheck if file is an ordinary file as opposed to a directory or special file if yes then condition becomes true.[ -f $file ] is true.
-g fileChecks if file has its set group ID (SGID) bit set if yes then condition becomes true.[ -g $file ] is false.
-k fileChecks if file has its sticky bit set if yes then condition becomes true.[ -k $file ] is false.
-p fileChecks if file is a named pipe if yes then condition becomes true.[ -p $file ] is false.
-t fileChecks if file descriptor is open and associated with a terminal if yes then condition becomes true.[ -t $file ] is false.
-u fileChecks if file has its set user id (SUID) bit set if yes then condition becomes true.[ -u $file ] is false.
-r fileChecks if file is readable if yes then condition becomes true.[ -r $file ] is true.
-w fileCheck if file is writable if yes then condition becomes true.[ -w $file ] is true.
-x fileCheck if file is execute if yes then condition becomes true.[ -x $file ] is true.
-s fileCheck if file has size greater than 0 if yes then condition becomes true.[ -s $file ] is true.
-e fileCheck if file exists. Is true even if file is a directory but exists.[ -e $file ] is true.
Example:

Here is an example which uses all the file test operators:

Assume a variable file holds an existing file name "/var/www/tutorialspoint/unix/test.sh" whose size is 100 bytes and has read, write and execute permission on:

#!/bin/sh
file="/var/www/tutorialspoint/unix/test.sh"
if [ -r $file ]
then
echo "File has read access"
else
echo "File does not have read access"
fi
if [ -w $file ]
then
echo "File has write permission"
else
echo "File does not have write permission"
fi
if [ -x $file ]
then
echo "File has execute permission"
else
echo "File does not have execute permission"
fi
if [ -f $file ]
then
echo "File is an ordinary file"
else
echo "This is sepcial file"
fi
if [ -d $file ]
then
echo "File is a directory" else
echo "This is not a directory"
fi
if [ -s $file ]
then
echo "File size is zero"
else
echo "File size is not zero"
fi
if [ -e $file ]
then
echo "File exists"
else
echo "File does not exist"
fi

This would produce following result:

File has read access
File has write permission
File has execute permission
File is an ordinary file
This is not a directory
File size is zero
File exists

There are following points to note down:

  • There must be spaces between operators and expressions for example 2+2 is not correct, where as it should be written as 2 + 2.
  • if...then...else...fi statement is a decision making statement which has been explained in next chapter.
C Shell Operators:

This lists down all the operators available in C Shell. Here most of the operators are very similar to what we have in C Programming language.

Operators are listed in order of decreasing precedence:

Arithmetic and Logical Operators:
OperatorDescription
( )Change precedence
~1's complement
!Logical negation
*Multiply
/Divide
%Modulo
+Add
-Subtract
<<Left shift
>>Right shift
==String comparison for equality
!=String comparison for non equality
=~Pattern matching
&Bitwise "and"
^Bitwise "exclusive or"
|Bitwise "inclusive or"
&&Logical "and"
||Logical "or"
++Increment
--Decrement
=Assignment
*=Multiply left side by right side and update left side
/=Divide left side by right side and update left side
+=Add left side to right side and update left side
-=Subtract left side from right side and update left side
^="Exclusive or" left side to right side and update left side
%=Divide left by right side and update left side with remainder
File Test Operators:

There are following operators to test various properties associated with a Unix file.
OperatorDescription
-r fileChecks if file is readable if yes then condition becomes true.
-w fileCheck if file is writable if yes then condition becomes true.
-x fileCheck if file is execute if yes then condition becomes true.
-f fileCheck if file is an ordinary file as opposed to a directory or special file if yes then condition becomes true.
-z fileCheck if file has size greater than 0 if yes then condition becomes true.
-d fileCheck if file is a directory if yes then condition becomes true.
-e fileCheck if file exists. Is true even if file is a directory but exists.
-o fileCheck if user owns the file. It returns true if user is the owner of the file.
Korn Shell Operators:

This lists down all the operators available in Korn Shell. Here most of the operators are very similar to what we have in C Programming language.

Operators are listed in order of decreasing precedence:

Arithmetic and Logical Operators:
OperatorDescription
+Unary plus
-Unary minus
!~Logical negation; binary inversion (one's complement)
*Multiply
/Divide
%Modulo
+Add
-Subtract
<<Left shift
>>Right shift
==String comparison for equality
!=String comparison for non equality
=~Pattern matching
&Bitwise "and"
^Bitwise "exclusive or"
|Bitwise "inclusive or"
&&Logical "and"
||Logical "or"
++Increment
--Decrement
=Assignment
File Test Operators:

There are following operators to test various properties associated with a Unix file.
OperatorDescription
-r fileChecks if file is readable if yes then condition becomes true.
-w fileCheck if file is writable if yes then condition becomes true.
-x fileCheck if file is execute if yes then condition becomes true.
-f fileCheck if file is an ordinary file as opposed to a directory or special file if yes then condition becomes true.
-s fileCheck if file has size greater than 0 if yes then condition becomes true.
-d fileCheck if file is a directory if yes then condition becomes true.
-e fileCheck if file exists. Is true even if file is a directory but exists.
« Previous | 1 | 2 | 3 | Next »


copyright © 2014 - all rights riserved by javatechnologycenter.com