Operators in Golang

In this tutorial, you will learn various types of operators used in Go programming languages.
We will discuss further how these operators are used in creating expressions that make up the Go code simple and easy.

What are operators in Golang?

Operators are the basic component in every programming language. An operator in any programming language is a symbol that represents the performance of some mathematical calculations or functions. Operators are used to performing specific operations on operands (variables and values). An operand is one of the inputs or an argument taken by an operator. For example addition of 20 + 30 =?  is an expression composed of both operands and operators, the numbers 20 & 30 represent the input or operands while the symbols” + “, “=” forms operators?

Operators can be classified into unary and binary types based on the operand's participation in an operation.

•     Unary operator: - Operator that works with one operand.
•     Binary operator:-Operator that works with two operands.

What are the types of operators in Golang?

Golang supports operators that are similar to other programming languages like 

1.     Sign operator
2.     Assignment operator
3.     Increment & decrement operator
4.     Arithmetic operator
5.     Boolean operator
6.     Comparison operator
7.     Bitwise operator  

In the next few sections, we are going to discuss each operator separately.

Sign operator in Golang

Sign operator represents a sign of a value in the Go programming language. There are mainly two types of sign operators.

The positive (“+”) and negative (“-“) sign operators represent a sign of the integer value of a variable declared in a Golang. Let us understand with a simple Go program given below

Example

package main
import "fmt"

func main() {

 var s = 1
// -(-1)= +1
fmt.Println(" + sign operator prints positive numbers ")
 fmt.Println(-(-s))
// -1 = -1 
fmt.Println(" - sign operator prints negative numbers ")
   fmt.Println(-s)
}

Output:

+ sign operator prints positive numbers 
1
 - sign operator prints negative numbers 
-1

In the above program, a variable s is declared using the var keyword the minus sign indicates the sign of integer whether it is a positive number or negative number.

Increment and decrement operator

Go supports increment and decrement operations as in many other programming languages to either increase (increment) or decrease (decrement) a value. The symbol that denotes increment operator is “++ “& the Decrement operator is “--“. Suppose if a variable x is declared and assigned value 10.ie var x = 10.

Let us understand the concept with an example

Example

package main
import "fmt"

func main() {

    x := 10

    x++  //increment operator x=x+1=10+1=11
    x++    //increment operator  x=11+1=12

    fmt.Println("The varaiable x is incremented two times ",x)

    x--      // decrement  operator x=12,x-1=12-1=11
    fmt.Println("The variable x is decremented one time ", x)
}

Output:

The varaiable x is incremented two times  12
The variable x is decremented one time  11

Arithmetic operators

Arithmetic operators are used to performing arithmetic operations between the operands.

package main
import ("fmt")
func main() {
  x:= 10
  y:= 2
  fmt.Println("Addition:",x+y)
  fmt.Println("Subtraction:",x-y)
  fmt.Println("Multiplication:",x*y)
  fmt.Println("Division:",x/y)
  fmt.Println("Modulus:",x%y)
}

Output:

Addition: 12
Subtraction: 8
Multiplication:20
Division:5
Modulus:0

Comparison operators

Comparison operators compare its left-hand-side value (or expression) with the right-hand-side value (or expression). Comparison operators are also known as relational operators. The output of an operation using a comparison operator will be a Boolean value that is true or false.

Example programs using Comparison operators:

• Equal (==)

  Go program to check if the two numbers are equal or not

  
  package main
  import ("fmt")
  func main() {
  
    var x = 3
    var y = 2
  
    fmt.Println(x==y) 
  }
  
  

  Output:

  
  false
  

• Not Equal (!=)

  Go program to check if the numbers are not equal

  
  package main
  import ("fmt")
  func main() {
  
    var x = 3
    var y = 2
  
    fmt.Println(x!=y) 
  }
  
  

  Output:

  
  true
  

• Greater (>)

  Go program to check if ‘x’ is greater than ‘y’

  
  package main
  import ("fmt")
  func main() {
  
    var x = 3
    var y = 2
  
    fmt.Println(x>y) 
  }
  
  

  Output:

  
  true
  

• Greater or equal (>=)

  Go program to check if ‘x’ is greater than or equal to ‘y’

  
  package main
  import ("fmt")
  func main() {
  
    var x = 3
    var y = 2
  
    fmt.Println(x>=y) 
  }
  
  

  Output:

  
  true
  

• Less (<)

  Go program to check if ‘x’ is less than ‘y’

  
  package main
  import ("fmt")
  func main() {
    var x = 3
    var y = 2
    fmt.Println(x<y)}

  Output:

  
  false
  

• Less or Equal (<=)

  Go program to check if ‘x’ is less than or equal to ‘y’

  
  packagemain
  import ("fmt")
  func main() {
  
    var x = 3
    var y = 2
  
    fmt.Println(x<=y) 
  }
  
  

  Output:

  
  false
  

Logical operators

Logical operators are used to performing the logical operations AND, OR, and NOT. The output of an operation using a logical operator will be a Boolean value that is true or false.

Example programs using Logical operators:

• AND (&&)

  Go program to check if the value of ‘x’ is greater than 4 and lesser than 6

  
  package main
  import ("fmt")
  func main() {
    var x = 5
    fmt.Println(x > 4 &&  x < 6) 
  }
  
  

  Output:

  
  true
  

• OR (||)

  Go program to check if the value of ‘x’ is lesser than 10 or greater than 20

  
  package main
  import ("fmt")
  func main() { 
  
    var x = 5
  
    fmt.Println(x < 10 || x > 20) 
  }
  
  

  Output:

  
  true
  

• NOT (!)

  Go program to print ‘true’ if the value of ‘x’ is greater than 4

  
  package main
  import ("fmt")
  func main() {
  
    var x = 5
  
    fmt.Println(!(x > 4))
  }
  
  

  Output:

  
  false
  

BitWise operators

BitWise operators are used to performing bitwise operations on binary numbers. First, the integers are converted into binary format and then the operations are performed bit by bit.

Example programs using BitWise operators:

• bitwise AND (&),bitwise OR (|),bitwise XOR (^)

  Example for bitwise AND, OR, XOR

  
  package main
  import ("fmt")
  func main() {
  
    var x = 10
    var y = 11
  
    fmt.Printf("x = %b\n",x)
    fmt.Printf("y = %b\n",y)
      
    fmt.Printf("x & y is %b\n",x & y)
    fmt.Printf("x | y is %b\n",x | y)
    fmt.Printf("x ^ y is %b\n",x ^ y)
  }
  
  

  Output:

  
  x = 11
  y = 10
  x & y is 10
  x | y is 11
  x ^ y is 1
  

• left shift (<<)

  Example program

  
  package main
  import ("fmt")
  func main() {
  
    var x = 10
    fmt.Printf("x = %b\n",x)
  
    fmt.Printf("x << 2 is %b\n",x << 2)
  }
  
  

  Output:

  
  x = 1010
  x << 2 is 101000
  

• right shift (>>)

  Example program

  
  package main
  import ("fmt")
  func main() {
  
    var x = 10
    fmt.Printf("x = %b\n",x)
   
    fmt.Printf("x >> 2 is %b\n",x >> 2)
  }
  
  

  Output:

  
  x = 1010
  x >> 2 is 10
  

• AND NOT ($^)

  Example program

  
  package main
  import ("fmt")
  func main() {
  
    var x = 5
    var y = 2
  
    fmt.Printf("x = %b\n",x)
    fmt.Printf("y = %b\n",y)
  
    fmt.Printf("x &^ y = %b\n",x &^ y)
  }
  
  

  Output:

  
  x = 101
  y = 10
  x & y is 101
  

Assignment operators

A variable is a placeholder that stores values in it for later use in the Go program. These values are assigned to a variable by means of an operator called the assignment operator.

The var keyword assigns value 4 to variable a using operator “ = “.

package main
import ("fmt")
func main() {

  var x = 2
  var a = 3
  var s = 3
  var m = 3
  var d = 3
  var md = 3
  a += 2
  s -=2
  m *= 2
  d /= 2
  md %= 2

  fmt.Println("Using Asignment operator :",x)
  fmt.Println("Using Add assignment operator :",a) 
  fmt.Println("Using Subtract assignment operator :",s) 
  fmt.Println("Using Multiply assignment operator :",m) 
  fmt.Println("Using Division assignment operator :",d) 
  fmt.Println("Using Modulus assignment operator :",md) 
}

Output:

Using asignment operator : 2
Using Add assignment operator : 5
Using Subtract assignment operator : 1
Using Multiply assignment operator : 6
Using Division assignment operator : 1
Using Modulus assignment operator  : 1

package main
import ("fmt")
func main() {

  var x = 3
  var y = 2
  fmt.Printf("x = %b\n",x)
  fmt.Printf("y = %b\n",y)
 x &= y
  fmt.Printf("x &= y = %b\n",x)
}

Output:

x = 11
y = 10
x &= y = 10

package main
import ("fmt")
func main() {

  var x = 3
  var y = 2
  fmt.Printf("x = %b\n",x)
  fmt.Printf("y = %b\n",y)
 x |= y
  fmt.Printf("x |= y = %b\n",x)
}

Output:

x = 11
y = 10
x |= y = 11

package main
import ("fmt")
func main() {

  var x = 5
  var y = 8
  fmt.Printf("x = %b\n",x)
  fmt.Printf("y = %b\n",y)
  x ^= y
  fmt.Printf("x ^= y = %b\n",x)
}

Output:

x = 101
y = 1000
x ^= y = 1101