How to use operators in Golang

Operators are the foundation of every programming language. Therefore, the functionality of Golang language is incomplete without the use of operators. Operators allow us to perform different types of operations on operands. In Go language, operators can be classified based on their different functions .

Arithmetic operators

These operators are used to perform operations on operands in Go language:

• Addition: '+' adds two operands. Example: x+y.
• Subtraction: '-' subtracts two operands. Example: xy.
• Multiplication: '*' multiplies two operands. Example: x*y.
• Division: '/' divides the first operand by the second operand. For example: x/y.
• Remainder: The '%' operator returns the remainder when the first operand is divided by the second operand. For example: x%y.

 Note: -, +, !, &, *, <- and ^ are also called unary operators and the precedence of unary operators is higher. The ++ and — operators come from statements, they are not expressions, so they lie outside the operator hierarchy.

For example:

//Minh họa chương trình Go dùng toán tử số học
package main 

import "fmt"

func main() { 
p:= 34
q:= 20
	
// Phép cộng
result1:= p + q 
fmt.Printf("Result of p + q = %d", result1) 
	
// Phép trừ
result2:= p - q 
fmt.Printf("\nResult of p - q = %d", result2) 
	
// Phép nhân
result3:= p * q 
fmt.Printf("\nResult of p * q = %d", result3) 
	
// Division 
result4:= p / q 
fmt.Printf("\nResult of p / q = %d", result4) 
	
// Modulus 
result5:= p % q 
fmt.Printf("\nResult of p %% q = %d", result5) 
} 

Result:

Kết quả của p + q = 54
Kết quả của p - q = 14
Kết quả của p * q = 680
Kết quả của p / q = 1
Kết quả của p % q = 14

Relational Operators

Relational operators are used to compare two values. Let's look at each operator one by one:

• The '=='(Equals) operator checks whether the two given operands are equal or not. If they are equal, it returns true. Otherwise, it returns false. For example, 5==5 will return true.
• The '!='(Not equal to) operator checks whether the two given operands are equal or not. If not, it returns true. Otherwise, it returns false. This is the exact boolean complement of the '==' operator. For example, 5!=5 will return false.
• The '>'(Greater than) operator checks whether the first operand is greater than the second operand. If greater, it returns true. If less, it returns false. For example, 6>5 will return true.
• The '<'(less than) operator checks whether the first operand is less than the second operand. If it is less, it returns true. If not, it returns false. For example, <5 will return
• '>='(Greater than equal)operator checks whether the first operand is greater than or equal to the second operand. If greater than or equal, it returns true. If less than or equal, it returns false. For example: 5>=5 will return true.
• The '<='(less than or equal to) operator checks if the first operand is less than or equal to the second operand. If it is greater than or equal, it returns true. If it is less than or equal, it returns false. For example: <=5 will also return

For example:

// Minh họa chương trình Go dùng toán tử quan hệ
package main 

import "fmt"

func main() { 
p:= 34
q:= 20
	
// ‘=='(Equal To) 
result1:= p == q 
fmt.Println(result1) 
	
// ‘!='(Not Equal To) 
result2:= p != q 
fmt.Println(result2) 
	
// ‘<‘(less than)="" result3:="p">< q="" fmt.println(result3)="" ‘="">'(Greater Than) 
result4:= p > q 
fmt.Println(result4) 
	
// ‘>='(Greater Than Equal To) 
result5:= p >= q 
fmt.Println(result5) 
	
// ‘<='(less than="" equal="" to)="" result6:="p"><= q="" fmt.println(result6)="" }="">

Result:

false
true
false
true
true
false

Logical operators

They are used to combine two or more conditions/constraints or to supplement the evaluation of the initial condition under consideration.

• AND: The '&&' operator returns true when both the conditions under consideration are satisfied. Otherwise, it returns false. For example, a && b returns true when both a and b are true (i.e. non-zero).
• OR: The '||' operator returns true if one (or both) of the conditions under consideration are satisfied. Otherwise, it returns false. For example, a || b returns true if either a or b is true (i.e. non-zero). Of course, it returns true when both a and b are true.
• Logical NOT: The '!' operator returns true when the condition under consideration is not satisfied. Otherwise, it returns false. For example, !a returns true if a is false, i.e. when a = 0.

For example:

// Minh họa chương trình Go dùng toán tử logic
package main 
import "fmt"
func main() { 
	var p int = 23
	var q int = 60
		
	if(p!=q && p<=q){ fmt.println("true")="" }="" if(p!="q" ||=""><=q){ fmt.println("true")="" }="" if(!(p="=q)){" fmt.println("true")="" }="" }="">

Result:

True
True
True

Bitwise operators

In Go language, there are 6 bitwise operators that operate on bit level or are used to perform bit-by-bit operations. Following are the bitwise operators:

• & (bitwise AND): Takes two numbers as operands and performs AND on every bit of the two numbers. The result of AND is 1 only if both bits are 1.
• | (bitwise OR): Takes two numbers as operands and performs OR on every bit of the two numbers. The result of OR is 1 if any of the two bits is 1.
• ^ (bitwise XOR): Takes two numbers as operands and performs XOR on all bits of the two numbers. The result of XOR is 1 if the two bits are different.
• < (shift left): takes two numbers, shifts the bits of the first operand left, the second operand determines the number of positions to shift
• >> (shift right): Take two numbers, shift the bits of the first operand right, the second operand determines the number of positions to shift.
• &^ (AND NOT): This is an explicit bitwise operator.

For example:

// Minh họa chương trình Go dùng toán tử bitwise
package main 

import "fmt"

func main() { 
p:= 34
q:= 20
	
// & (bitwise AND) 
result1:= p & q 
fmt.Printf("Result of p & q = %d", result1) 
	
// | (bitwise OR) 
result2:= p | q 
fmt.Printf("\nResult of p | q = %d", result2) 
	
// ^ (bitwise XOR) 
result3:= p ^ q 
fmt.Printf("\nResult of p ^ q = %d", result3) 
	
// < (left="" shift)="" result4:="p">< 1="" fmt.printf("\nresult="" of="" p="">< 1="%d" ,"="" result4)="">> (right shift) 
result5:= p >> 1
fmt.Printf("\nResult of p >> 1 = %d", result5) 
	
// &^ (AND NOT) 
result6:= p &^ q 
fmt.Printf("\nResult of p &^ q = %d", result6) 
	
	
} 

Result:

Kết quả của p & q = 0
Kết quả của p | q = 54
Kết quả của p ^ q = 54
Kết quả của p < 1="68" kết="" quả="" của="" p="">> 1 = 17
Kết quả của p &^ q = 34

Assignment Operator

Assignment operators are used to assign a value to a variable. The left operand of an assignment operator is a variable and the right operand of an assignment operator is a value. The value on the right must have the same data type as the variable on the left, otherwise the compiler will report an error. The different types of assignment operators are shown below:

• “=”(Simple assignment): This is the simplest assignment operator. This operator is used to assign the value on the right to the variable on the left.
• “+=”(Additional Assignment): This operator is a combination of the '+' and '=' operators. This operator first adds the current value of the left variable to the value on the right, and then assigns the result to the left variable.
• “-=”(Subtraction Assignment): This operator is a combination of the '-' and '=' operators. This operator first subtracts the current value of the left variable from the value on the right, and then assigns the result to the left variable.
• “*=”(Multiplication Assignment): This operator is a combination of the '*' and '=' operators. This operator first multiplies the current value of the left variable by the value on the right, and then assigns the result to the left variable.
• “/=”(Division assignment): This operator is a combination of the '/' and '=' operators. This operator first divides the current value of the left variable by the value on the right, and then assigns the result to the left variable.
• “%=”(Assignment with remainder division): This operator is a combination of the '%' and '=' operators. This operator first takes the remainder of the current value of the left variable to the value on the right, and then assigns the result to the left variable.
• “&=”(Bitwise AND assignment): This operator is a combination of the '&' and '=' operators. This operator first “bitwise ANDs” the current value of the left variable to the value on the right, and then assigns the result to the left variable.
• “^=”(Bitwise Exclusive OR): This operator is a combination of the '^' and '=' operators. This operator first “Bitwise Exclusive OR” the current value of the left variable by the value on the right and then assigns the result to the left variable.
• “|=”(Bitwise Inclusive OR): This operator is a combination of the '|' and '=' operators. This operator first “Bitwise Inclusive OR” the current value of the left variable by the value of the right and then assigns the result to the left variable.
• “<=: This operator is a combination of the < ' and '="' operators." This operator first “shifts” the current value of the variable on the left by the value on the right and then assigns the result to the variable on the right.
• “>>=”: This operator is a combination of the '>>' and '=' operators. This operator first “Right Shift ANDs” the current value of the left variable by the value on the right, and then assigns the result to the left variable.

For example:

// Minh họa chương trình Go dùng toán tử gán
package main 
	
import "fmt"
	
func main() { 
var p int = 45
	var q int = 50
	
// “=”(Simple Assignment) 
p = q 
fmt.Println(p) 
	
// “+=”(Add Assignment) 
	p += q 
fmt.Println(p) 
	
//“-=”(Subtract Assignment) 
p-=q 
fmt.Println(p) 
	
// “*=”(Multiply Assignment) 
p*= q 
fmt.Println(p) 
	
// “/=”(Division Assignment) 
	p /= q 
fmt.Println(p) 
	
	// “%=”(Modulus Assignment) 
	p %= q 
fmt.Println(p) 
	
} 

Result:

50
100
50
2500
50
0

Other operators

• &: This operator returns the address of a variable.
• *: This operator provides a pointer to a variable.
• <-: The name of this operator is receive. It is used to receive a value from

// Minh họa chương trình sử dụng toán tử khác
package main 
	
import "fmt"
	
func main() { 
a := 4
	
// Dùng địa chỉ của toán tử (&) toán tử trỏ gián tiếp (*)

b := &a 
fmt.Println(*b) 
*b = 7
fmt.Println(a) 
} 

Result:

4
7