Go - Operators

---

---

An operator is a symbol that tells the compiler to perform specific mathematical or logical manipulations. Go language is rich in built-in operators and provides the following types of operators −

• Arithmetic Operators
• Relational Operators
• Logical Operators
• Bitwise Operators
• Assignment Operators
• Miscellaneous Operators

This tutorial explains arithmetic, relational, logical, bitwise, assignment, and other operators one by one.

Arithmetic Operators

The arithmetic operators perform mathematical operations on numeric values.

Following table shows all the arithmetic operators supported by Go language. Assume variable A holds 10 and variable B holds 20 then −

Example

The following is an example of arithmetic operators in Go:

package main

import "fmt"

func main() {
    var a, b int = 10, 5

    // Addition
    sum := a + b
    fmt.Println("Sum:", sum)

    // Subtraction
    difference := a - b
    fmt.Println("Difference:", difference)

    // Multiplication
    product := a * b
    fmt.Println("Product:", product)

    // Division
    quotient := a / b
    fmt.Println("Quotient:", quotient)
}

When the above code is compiled and executed, it produces the following result −

Sum: 15
Difference: 5
Product: 50
Quotient: 2

Relational Operators

The relational operators compare the values and return a Boolean value, which can be either true or false.

The following table lists all the relational operators supported by Go language. Assume variable A holds 10 and variable B holds 20, then −

Example

The following is an example of relational operators in Go:

package main

import "fmt"

func main() {
    var a, b int = 10, 5

    // Equal to
    fmt.Println(a == b)

    // Not equal to
    fmt.Println(a != b)

    // Greater than
    fmt.Println(a > b)

    // Less than
    fmt.Println(a < b)

    // Greater than or equal to
    fmt.Println(a >= b)

    // Less than or equal to
    fmt.Println(a <= b)
}

When the above code is compiled and executed, it produces the following result −

false
true
true
false
true
false

Logical Operators

The logical operators perform the logical operation on Boolean values. These are basically used to check more than one condition together.

The following table lists all the logical operators supported by Go language. Assume variable A holds 1 and variable B holds 0, then −

The following table shows all the logical operators supported by Go language. Assume variable A holds true and variable B holds false, then −

Example

The following is an example of logical operators in Go:

package main

import "fmt"

func main() {
    var a, b bool = true, false

    // Logical AND (&&)
    fmt.Println(a && b)

    // Logical OR (||)
    fmt.Println(a || b)

    // Logical NOT (!)
    fmt.Println(!a)
}

When the above code is compiled and executed, it produces the following result −

false
true
false

Bitwise Operators

Bitwise operators work on bits and perform bit-by-bit operation. The truth tables for &, |, and ^ are as follows −

Assume A = 60; and B = 13. In binary format, they will be as follows −

A = 0011 1100

B = 0000 1101

-----------------

A&B = 0000 1100

A|B = 0011 1101

A^B = 0011 0001

~A  = 1100 0011

The Bitwise operators supported by C language are listed in the following table. Assume variable A holds 60 and variable B holds 13, then −

Example

The following is an example of bitwise operators in Go:

package main

import "fmt"

func main() {
    var a, b int = 5, 3

    // Bitwise AND
    fmt.Println(a & b) 

    // Bitwise OR
    fmt.Println(a | b)

    // Bitwise XOR
    fmt.Println(a ^ b)

    // Bitwise AND NOT
    fmt.Println(a &^ b)

    // Left shift
    fmt.Println(a << 1) 

    // Right shift
    fmt.Println(a >> 1)
}

When the above code is compiled and executed, it produces the following result −

1
7
6
4
10
2

Assignment Operators

The following table lists all the assignment operators supported by Go language −

Example

The following is an example of assignment operators in Go:

package main

import "fmt"

func main() {
    var a, b int = 10, 5

    // Simple assignment
    a = b
    fmt.Println("a =", a)

    // Add and assign
    a += b
    fmt.Println("a += b:", a)

    // Subtract and assign
    a -= b
    fmt.Println("a -= b:", a)

    // Multiply and assign
    a *= b
    fmt.Println("a *= b:", a)

    // Divide and assign
    a /= b
    fmt.Println("a /= b:", a)

    // Modulo and assign
    a %= b
    fmt.Println("a %= b:", a)

    // Bitwise AND and assign
    a = 10 // Reset a
    a &= b
    fmt.Println("a &= b:", a)

    // Bitwise OR and assign
    a = 10 // Reset a
    a |= b
    fmt.Println("a |= b:", a)

    // Bitwise XOR and assign
    a = 10 // Reset a
    a ^= b
    fmt.Println("a ^= b:", a)

    // Left shift and assign
    a = 10 // Reset a
    a <<= 1
    fmt.Println("a <<= 1:", a)

    // Right shift and assign
    a = 10 // Reset a
    a >>= 1
    fmt.Println("a >>= 1:", a)
}

When the above code is compiled and executed, it produces the following result −

a = 5
a += b: 10
a -= b: 5
a *= b: 25
a /= b: 5
a %= b: 0
a &= b: 0
a |= b: 15
a ^= b: 15
a <<= 1: 20
a >>= 1: 5

Miscellaneous Operators

There are a few other important operators (miscellaneous operators) supported by Go Language including sizeof and ?:.

Operators Precedence in Go

Operator precedence determines the grouping of terms in an expression. This affects how an expression is evaluated. Certain operators have higher precedence than others; for example, the multiplication operator has higher precedence than the addition operator.

For example x = 7 + 3 * 2; here, x is assigned 13, not 20 because operator * has higher precedence than +, so it first gets multiplied with 3*2 and then adds into 7.

Here, operators with the highest precedence appear at the top of the table, those with the lowest appear at the bottom. Within an expression, higher precedence operators will be evaluated first.