# Operators Operators allow you to perform operations on values and variables in Bash. Bash provides various types of operators for different purposes: * Arithmetic Operators * Assignment Operators * Relational Operators * Logical Operators * Bitwise Operators * Ternary Operator ### Arithmetic Operator Arithmetic operators allow you to perform mathematical operations on integers. They combine integer variables and values to produce a new integer result.

Operator	Description	Example
+	Addition	$a + $b
-	Subtraction	$a - $b
*	Multiplication	$a * $b
/	Division	$a / $b
%	Modulus (remainder)	$a % $b
**	Exponentiation (a to the power b)	$a ** $b

```bash #!/bin/bash # reading data from the user read -r -p "Enter a: " a read -r -p "Enter b: " b add=$((a+b)) echo "Addition of a and b are: "${add} sub=$((a-b)) echo "Subtraction of a and b are: "${sub} ``` ### Assignment Operator Assignment operators store values or the result of an expression into a variable.

Operator	Description	Example
=	Simple assignment	a=5
+=	Add and assign	a+=2
-=	Subtract and assign	a-=3
*=	Multiply and assign	a*=4
/=	Divide and assign	a/=5
%=	Modulus and assign	a%=6

Simple assignment allows storing values in a variable. The combined assignment operators like += and -= allow modifying variables more concisely. For instance, a+=b is the same as a = a + b. ```bash #!/bin/bash # Assigning a value to a variable greeting="Hello, World!" # Displaying the value of the variable echo $greeting ``` ### Relational Operator Relational operators are used for comparing integers and strings to evaluate conditions.

Operator	Description	Example
-eq	Equal to	[ $a -eq $b ]
-ne	Not Equal to	[ $a -ne $b ]
-gt	Greater than	[ $a -gt $b ]
-ge	Greater than or equal to	[ $a -ge $b ]
-lt	Less than	[ $a -lt $b ]
-le	Less than or equal to	[ $a -le $b ]
<	Less than (strings)	[ "$a" < "$b" ]
<=	Less than or equal (strings)	[ "$a" <= "$b" ]
>	Greater than (strings)	[ "$a" > "$b" ]
=>	Greater than or equal (strings)	[ "$a" >= "$b" ]
==	Equal to	[ $a == $b ]
!=	Not equal to	[ $a != $b ]

-eq, -ne, -gt, -ge, -lt, and -le work on integers, while <, <=, >, and >= work on string sorting order. These are commonly used in if statements and loops to control program flow. The equal (==) and not equal (!=) operators are useful for comparing integers. ```bash #!/bin/bash # Assigning two variables num1=10 num2=20 # Using relational operators in an if-else statement if [ $num1 -eq $num2 ]; then echo "num1 is equal to num2" elif [ $num1 -lt $num2 ]; then echo "num1 is less than num2" else echo "num1 is greater than num2" fi ``` ### Logical Operator Logical operators are used for combining and negating conditional expressions.

Operator	Description	Example
!	Negation	! [ $a -eq $b ]
&&	AND	[ $a -eq 5 ] && [ $b -eq 10 ]
\|\|	OR	[ $a -eq 5 ] \|\| [ $b -eq 10 ]

The NOT operator (!) inverts a true condition to false or a false condition to true. The AND operator (&&) evaluates to true if both operands are true, while the OR operator (||) evaluates to true if either operand is true. These allow creating complex conditional logic in scripts. ```bash #!/bin/bash # Assign values to variables a=10 b=20 # Check if both conditions are true if [[ $a -lt 15 && $b -gt 15 ]]; then echo "Both conditions are true: a is less than 15 and b is greater than 15." else echo "One or both conditions are false." fi ``` ### Bitwise Operator Bitwise operators manipulate integers at the bit level. | Operator | Description | Example | | -------- | ----------- | -------- | | & | Bitwise AND | $a & $b | | \| | Bitwise OR | $a \| $b | | \~ | Bitwise NOT | \~$a | | ^ | Bitwise XOR | $a ^ $b | | << | Left shift | $a << 2 | | >> | Right shift | $a >> 2 | Bitwise operators treat integers as binary strings and set, unset, or toggle bits at specific positions. This allows bit masking, toggling, and shifting values for flags and low-level binary operations. ```bash #!/bin/bash # Assign two numbers a=5 # Binary: 0101 b=3 # Binary: 0011 # Bitwise AND and_result=$((a & b)) echo "a & b = $and_result" # Result: 1 (Binary: 0001) # Bitwise OR or_result=$((a | b)) echo "a | b = $or_result" # Result: 7 (Binary: 0111) # Bitwise XOR xor_result=$((a ^ b)) echo "a ^ b = $xor_result" # Result: 6 (Binary: 0110) # Bitwise NOT (Note: ~ inverts all the bits, including the sign bit for integers) not_result=$((~a)) echo "~a = $not_result" # Result: -6 (Binary: Inverted bits of 5) # Left Shift left_shift_result=$((a << 1)) echo "a << 1 = $left_shift_result" # Result: 10 (Binary: 1010) # Right Shift right_shift_result=$((a >> 1)) echo "a >> 1 = $right_shift_result" # Result: 2 (Binary: 0010) ``` ### Ternary Operator The ternary operator allows simple conditional expressions.

Syntax	Description	Example
? :	Evaluates test condition and returns the "if true" or "if false" result

The ternary operator is structured as `condition ? resultIfTrue : resultIfFalse`. It tests the given condition and returns the specified result depending on whether the condition evaluated to true or false. This provides a concise way to assign values based on conditions. ```bash #!/bin/bash # Assign value based on a condition num=5 result=$(if [ $num -gt 3 ]; then echo "Greater than 3"; else echo "Not greater than 3"; fi) # Display the result echo $result ```