In computer programming, an operator is a symbol that performs operations on a value or a variable.

For example, `+`

is an operator that is used to add two numbers.

Go programming provides a wide range of operators that are categorized into the following major categories:

- Arithmetic operators
- Assignment operator
- Relational operators
- Logical operators

## Arithmetic Operator

We use arithmetic operators to perform arithmetic operations like addition, subtraction, multiplication, and division.

Here's a list of various arithmetic operators available in Go.

Operators | Example |
---|---|

`+` (Addition) |
`a + b` |

`-` (Subtraction) |
`a - b` |

`*` (Multiplication) |
`a * b` |

`/` (Division) |
`a / b` |

`%` (Modulo Division) |
`a % b` |

### Example 1: Addition, Subtraction and Multiplication Operators

```
package main
import ("fmt")
func main() {
num1 := 6
num2 := 2
// + adds two variables
sum := num1 + num2
fmt.Printf("%d + %d = %d\n", num1, num2, sum)
// - subtract two variables
difference := num1 - num2
fmt.Printf("%d - %d = %d\n",num1, num2, difference)
// * multiply two variables
product := num1 = num2
fmt.Printf("%d * %d is %d\n",num1, num2, product)
}
```

**Output**

6 + 2 = 8 6 - 2 = 4 6 * 2 = 12

### Example 2: Golang Division Operator

```
package main
import ("fmt")
func main() {
num1 := 11
num2 := 4
// * divide two integer variables
quotient := num1 / num2
fmt.Printf(" %d / %d = %d\n", num1, num2, division)
}
```

**Output**

11 / 4 = 2

In the above example, we have used the `/`

operator to divide two numbers: `11`

and `4`

. Here, we get the output `2`

.

However, in normal calculation, `11 / 4`

gives `2.75`

. This is because when we use the `/`

operator with integer values, we get the quotients instead of the actual result.

If we want the actual result we should always use the `/`

operator with floating point numbers. For example,

```
package main
import ("fmt")
func main() {
num1 := 11.0
num2 := 4.0
// / divide two floating point variables
result := num1 / num2
fmt.Printf(" %g / %g = %g\n", num1, num2, result)
}
```

**Output**

11 / 4 = 2.75

Here, we get the actual result after division.

### Example 3: Modulus Operator in Go

```
package main
import ("fmt")
func main() {
num1 := 11
num2 := 4
// % modulo-divides two variables
reminder := num1 % num2
fmt.Println(moduloDivision)
}
```

In the above example, we have used the modulo operator with numbers: `11`

and `4`

. Here, we get the result `3`

.

This is because, in programming, the modulo operator always returns the remainder after division.

**Note:** The modulo operator is always used with integer values.

## Increment and Decrement Operator in Go

In golang, we use `++`

(increment) and `--`

(decrement) operators to increase and decrease the value of a variable by 1 respectively. For example,

```
package main
import ("fmt")
func main() {
num := 5
// increment of num by 1
num++
fmt.Println(num) // 6
// decrement of num by 1
num--
fmt.Println(num) // 4
}
```

In the above example,

`num++`- increases the value of`num`by`1`

, from`5`

to`6`

`num--`- decreases the value of`num`by`1`

, from`5`

to`4`

**Note:** We have used `++`

and `--`

as prefixes (before variable). However, we can also use them as postfixes (`num++` and `num--`).

There is a slight difference between using increment and decrement operators as prefixes and postfixes. To learn the difference, visit Increment and Decrement Operator as Prefix and Postfix.

## Go Assignment Operators

We use the assignment operator to assign values to a variable. For example,

`var number = 34`

Here, the `=`

operator assigns the value on right (**34**) to the variable on left (`number`).

### Example: Assignment Operator in Go

```
package main
import ("fmt")
func main() {
num := 6
var result int
// assigns the value of num to result
result = num
fmt.Println(result) // 6
}
```

In the above example, we have used the assignment operator to assign the value of the `num` variable to the `result` variable.

### Compound Assignment Operators

In Go, we can also use an assignment operator together with an arithmetic operator. For example,

```
number := 2
number += 6
```

Here, `+=`

is additional assignment operator. It first adds **6** to the value of `number` (**2**) and assigns final result (**8**) to `number`

.

Here's a list of various compound assignment operators available in golang.

Operator | Example | Same as |
---|---|---|

`+=` (addition assignment) |
`a += b` |
`a = a + b` |

`-=` (subtraction assignment) |
`a -= b` |
`a = a - b` |

`*=` (multiplication assignment) |
`a *= b` |
`a = a * b` |

`/=` (division assignment) |
`a /= b` |
`a = a / b` |

`%=` (modulo assignment) |
`a %= b` |
`a = a % b` |

## Relational Operators in Golang

We use the relational operators to compare two values or variables. For example,

`5 == 6`

Here, `==`

is a relational operator that checks if `5`

is equal to `6`

.

A relational operator returns

`true`

if the comparison between two values is correct`false`

if the comparison is wrong

Here's a list of various relational operators available in Go:

Operator | Example | Descriptions |
---|---|---|

`==` (equal to) |
`a == b` |
returns `true` if `a` and `b` are equal |

`!=` (not equal to) |
`a != b` |
returns `true` if `a` and `b` are not equal |

`>` (greater than) |
`a > b` |
returns `true` if `a` is greater than `b` |

`<` (less than) |
`a < b` |
returns `true` if `a` is less than `b` |

`>=` (greater than or equal to) |
`a >= b` |
returns `true` if `a` is either greater than or equal to `c` |

`<=` (less than or equal to) |
`a <= b` |
returns `true` is `a` is either less than or equal to `b` |

To learn more, visit *Go relational operators*.

## Logical Operators in Go

We use the logical operators to perform logical operations. A logical operator returns either `true`

or `false`

depending upon the conditions.

Operator | Description | Example |
---|---|---|

`&&` (Logical AND) |
`exp1 && exp2` |
returns `true` if both expressions `exp1` and `exp2` are `true` |

`||` (Logical OR) |
`exp1 || exp2` |
returns `true` if any one of the expressions is `true` . |

`!` (Logical NOT) |
`!exp` |
returns `true` if `exp` is `false` and returns `false` if `exp` is `true` . |

To learn more, visit *Go logical operators*.

## More on Go Operators

The right shift operator shifts all bits towards the right by a certain number of specified bits.

Suppose we want to right shift a number **212** by some bits then,

```
212 = 11010100 (In binary)
212 >> 3 = 00011010 = 26 (Right shift by 3 bits)
212 >> 7 = 00000001 = 1 (Right shift by 7 bits)
212 >> 0 = 11010100 = 212 (No Shift)
```

For example,

```
package main
import "fmt"
func main() {
num := 212
for i := 0; i <= 3; i++ {
// right shift 212 by bits from 0 to 3
fmt.Printf("Right Shift by %d: %d\n", i, num>>i)
}
}
```

**Output**

Right Shift by 0: 212 Right Shift by 1: 106 Right Shift by 2: 53 Right Shift by 3: 26

The left shift operator shifts all bits towards the left by a certain number of specified bits. The bit positions that have been vacated by the left shift operator are filled with **0**.

Suppose we want to left shift a number **212** by some bits then,

```
212 = 11010100 (In binary)
212 << 1 = 110101000 = 424 (Adds one 0 to the right)
212 << 3 = 11010100000 = 1696 (Adds three 0's to the right)
212 << 0 = 11010100 = 212 (No Shift)
```

For example,

```
package main
import "fmt"
func main() {
num := 212
for i := 0; i <= 3; i++ {
// left shift 212 by bits from 0 to 3
fmt.Printf("Left Shift by %d: %d\n", i, num<<i)
}
}
```

**Output**

Left Shift by 0: 212 Left Shift by 1: 424 Left Shift by 2: 848 Left Shift by 3: 1696

In Go, `&`

is the address operator that is used for pointers. It holds the memory address of a variable. For example,

```
package main
import ("fmt")
func main() {
num := 20
// &num prints the
// memory address where 20 is stored
fmt.Println(&num)
}
// Output: 0xc0000b8000
```

Here, we are printing the `&num`. This gives the memory address where the `num` variable is stored. To learn more visit, *Go Address and Pointers*.

In Go, `*`

is the dereferencing operator used to declare a pointer variable. A pointer variable stores the memory address. For example,

```
package main
import ("fmt")
func main() {
b := 20
// pointer declaration
var num *int = &b
// gives the memory address
fmt.Println(num)
}
// Output: 0xc00010a000
```

Here, we have used the `*`

operator to declare the pointer variable. To learn more, visit *Go Pointers*.

In Go, we use the concept called operator precedence which determines which operator is executed first if multiple operators are used together. For example,

`result := 32 / 8 + 2 * 9 -4`

Here, the `/`

operator is executed first followed by the `*`

operator. The `+`

and `-`

operators are respectively executed at last.

This is because operators with the higher precedence are executed first and operators with lower precedence are executed last.