# Go Operators

Operators are symbols that allow us to perform various mathematical and logical operations on values and variables.

In Go, operators can be classified as below:

• Arithmetic
• Comparison
• Logical
• Bitwise
• Assignment

## Arithmetic Operators

The arithmetic operators can be used in the basic arithmetic operations on literal values or variables.

Operator Description Syntax
+ Addition. Adds two values x + y
- Subtraction. Subtracts the second operand from the first x – y
* Multiply x * y
/ Divide x / y
% Modulus. Gives the reminder after division x % y
++ Increment operator. Increments the value by 1 x ++
-- Decrement operator. Decreases the value by 1 x --

The following example demonstrates arithmetic operations such as addition, subtraction, and modulus.

Example: Arithmetic Operators
``````package main
import "fmt"

func main() {
x := 5
y := 4

// Add x and y variables
resultAdd := x + y

//Subtract y from x
resultSub := x – y
fmt.Printf(resultSub) // output: 1

//Modulus of x and y
resultMod := x % y
fmt.Printf(resultMod) // output: 1
}
``````

## Comparison Operators

Comparison operators are used to compare two literal values or variables.

Operator Description Syntax
== Equal x == y
!= Not Equal x != y
< Less than x < y
<= Less than or equal x <= y
> Greater than x > y
>= Greater than or equal x >= y

The following example demonstrates comparisons operators.

Example: Comparisons operators
``````package main
import "fmt"

func main() {
x := 5
y := 4

fmt.Println (x == y) // output: false
fmt.Printfln(x != y) // output: true
fmt.Println (x < y) // output: false
fmt.Println (x <= y) // output: false
fmt.Println (x > y) // output: true
fmt.Println (x >= y) // output: true
}
``````

## Logical Operators:

The logical operators are used to perform logical operations by combining two or more conditions. They return either true or false depending upon the conditions.

Operator Description Syntax
&& Logical AND. Returns true if both expressions are true expression1 && expression2
|| Logical OR. Returns true if any one of the expressions is true. exp1 || exp2
! Logical NOT. Returns true if an expression is true. Returns false if the expression is false. ! exp

The following example demonstrates the logical operators.

Example: Logical Operators
``````package main
import "fmt"

func main() {
x ,y, z  := 5, 10, 20

fmt.Println (x < y && x > z) //output: false
fmt.Println(x < y || x < z) //output: true
}
``````

## Bitwise Operators

The bitwise operators work on bits and perform bit-by-bit operation.

Operator Description
& bitwise AND
| bitwise OR
^ bitwise XOR
<< left shift
>> Right shift

The following example demonstrates the bitwise operations.

Example:
``````package main
import "fmt"

func main() {

var x, y = 3, 5
var z int

//Bitwise AND
z = x & y
fmt.Println("Bitwise AND ", z) // output: 1

//Bitwise OR
z = x | y
fmt.Println("Bitwise OR ", z) //output: 7

//Bitwise XOR
z = x ^ y
fmt.Println("Bitwise XOR ", z) //output: 6
}
``````

In the above example, two int variables are `x = 3` and `y = 5`. Binary of 3 is 0011 and 5 is 0101. so, `x & y` is 0001, which is numeric 1. `x | y` is 0111 which is numeric 7, and `x ^ y ` is 0110 which is numeric 6.

## Assignment Operators

The assignment operators are used to assign literal values or assign values by performing some arithmetic operation using arithmetic operators.

Operator Description Syntax
= Assign value x = y
+= Add and assign x += y same as x = x + y
-= Subtract and assign x -= y same as x = x - y
*= Multiply and assign x *= y same as x = x * y
/= Divide and assign x /= y same as x = x/y
%= Divide and assign modulus x %= y same as x = x%y

The following example demonstrates the assignment operators.

Example: Assignment Operators
``````package main
import "fmt"

func main() {
x, y := 10, 20

//Assign
x = y
fmt.Println(" = ", x) //output: 20

// Add and assign
x = 15
x += y
fmt.Println("+= ", x) //output: 35

// Subtract and assign
x = 25
x -= y
fmt.Println("-=", x) //output: 5

//Multiply and assign
x = 2
x *= y
fmt.Println("*=", x) //output: 40

//Divide and assign
x = 100
x /= y
fmt.Println("/=", x) // output: 5

//Divide and assign modulus
x = 30
x %= y
fmt.Println(" %= ", x) //output: 10
}
``````