Arithmetic Operators
Arithmetic operators are used to perform common arithmetical operations, such as addition, subtraction, multiplication, etc.
 Addition: The '+' operator adds two operands—for example, x+y.
 Subtraction: The '' operator subtracts two operands—for example, xy.
 Multiplication: The '*' operator multiplies two operands—for example, a*b.
 Division: Here '/' operator divides the first operand by the second—for example, x/y.
 Modulus: The '%' operator returns the remainder value when the first operand is divided by the second—for example, x%y.
Example
package main
import "fmt"
func main()
{
var x, y = 35, 7
fmt.Printf("x + y = %d\n", x+y)
fmt.Printf("x  y = %d\n", xy)
fmt.Printf("x * y = %d\n", x*y)
fmt.Printf("x / y = %d\n", x/y)
fmt.Printf("x mod y = %d\n", x%y)
x++
fmt.Printf("x++ = %d\n", x)
y
fmt.Printf("y = %d\n", y)
}
Output
x + y = 42
x  y = 28
x * y = 245
x / y = 5
x mod y = 0
x++ = 36
y = 6
Assignment Operators
 "=" (Simple Assignment): This is the most straightforward assignment operator. This operator is used to assign all values at the proper to the variable at the left.
 "+=" (Add Assignment): This operator is the combination of '+' and '=' operators. This operator first adon the left presentday value of the variable at the left to the value at the proper and then assigns the result to the variable on the left.
 "=" (Subtract Assignment): This operator first subtracts the presentday value of the variable on the left from the value at the proper and then assigns the result to the variable on the left.
 "*=" (Multiply Assignment): This operator is the mixture of '*' and '=' operators. This operator first multiplies the given value of the variable at the left to the value on the right, and after that, it assigns the result to the variable on the left.
 "/=" (Division Assignment): This operator is the combination of '/' and '=' operators. This operator first divides the given value of the variable on the left by the value at the right and then assigns the end result to the variable at the left.
 "%=" (Modulus Assignment): This operator is the mixture of '%' and '=' operators. This operator first modulo the given value of the variable on the left by way of the value at the right and then assigns the end result to the variable on the left.
 "&=" (Bitwise AND Assignment): This operator is the mixture of '&' and '=' operators. This operator first "Bitwise AND" the given value of the variable on the left by the cost at the right and then assigns the result to the variable at the left.
 "^=" (Bitwise Exclusive OR): This operator is the mixture of '^' and '=' operators. This operator first "Bitwise exclusive OR" the given value of the variable on the left via the price at the right and then assigns the end result to the variable at the left.
 "=" (Bitwise Inclusive OR): This operator is the mixture of '' and '=' operators. This operator first "Bitwise Inclusive OR" the given value of the variable on the left via the fee at the right, after which it assigns the result to the variable at the left.
Example
package main
import "fmt"
func main() {
var x, y = 15, 25
x = y
fmt.Println("= ", x)
x = 15
x += y
fmt.Println("+=", x)
x = 50
x = y
fmt.Println("=", x)
x = 2
x *= y
fmt.Println("*=", x)
x = 100
x /= y
fmt.Println("/=", x)
x = 40
x %= y
fmt.Println("%=", x)
}
Output
= 25
+= 40
= 25
*= 50
/= 4
%= 15
Relational Operators
This operator is mainly used to compare two values. Let's see them one by one:
 '!=' (Not Equal To) The operator compares the two operands to see if they are equal. It returns true when the condition is not met. It returns false otherwise. The '==' operator has an exact boolean complement. 5!=5 returns false, for example.
 '==' (Equal To) operator checks when the two given operands are equal or not. It returns true. Otherwise, it returns false. For example, 5==5 will return true.
 The '>' (Greater Than)operator checks whether the first operand is greater than the second. It returns true. Otherwise, it returns the false. For example, 6>5 will return true.
 '< '(Less Than)operator checks whether the first operand is lesser than the second. If so, it returns true. Otherwise, it returns false. For example, 6<5 will return false.
 '>=' (Greater Than Equal To)The operator compares the first and second operands to see if the first operands are larger than or equal to the second operands. When this is the case, it returns true. Otherwise, false is returned. 5>=5 will, for example, return true.
 '<=' (Less Than Equal To)operator checks whether the first operand is lesser than or equal to the second operand. It returns true. Otherwise, it returns false. For example, 5<=5 will also return true.
Example
package main
import "fmt"
func main() {
var x, y = 15, 25
fmt.Println(x == y)
fmt.Println(x != y)
fmt.Println(x < y)
fmt.Println(x <= y)
fmt.Println(x > y)
fmt.Println(x >= y)
}
Output
false
true
true
true
false
False
Logical Operators
They combine two or more conditions/constraints or complement the evaluation of the original condition in consideration.
 Logical AND: When both of the conditions in question are true, the && operator returns true; otherwise, it returns false. When a and b are true, for example, a && b returns true.(i.e., nonzero).
 Logical OR: The  operator returns true when one (or both) of the situations in consideration is satisfied; else, it returns false. For example, a  b returns true when one of a or b is true (i.e., nonzero). Of course, it returns true when both a and b are true.
 Logical NOT: The ! operator returns true the condition in consideration is not satisfied; else, it returns false. For example, !a returns true when a is false, i.e., when a=0.
Example
package main
import "fmt"
func main() {
var x, y, z = 10, 20, 30
fmt.Println(x < y && x > z)
fmt.Println(x < y  x > z)
fmt.Println(!(x == y && x > z))
}
Output
false
true
true
Bitwise Operators
In Go language, six bitwise operators work at bit level or perform bit by bit operations. Following are the bitwise operators:
 &: When we take two numbers as operands and do AND on every bit of two numbers. The result of AND is 1 if both bits are 1.
 : When we take two numbers as operands and do OR on each bit of two numbers. The result of OR is 1 when any of the two bits is 1.
 ^: When we take two numbers as operands and do XOR on every bit of two numbers. The result of XOR is 1 if two bits are different.
 <<: When we take two numbers, left shifts the bits of the first operand, the second operand decides the number of places to shift.
 >>: When we take two numbers, right shifts the bits of the first operand, the second operand decides the number of places to shift.
 &^: This is a bit clear operator.
Example
package main
import "fmt"
func main() {
var x uint = 9 //0000 1001
var y uint = 65 //0100 0001
var z uint
z = x & y
fmt.Println("x & y =", z)
z = x  y
fmt.Println("x  y =", z)
z = x ^ y
fmt.Println("x ^ y =", z)
z = x << 1
fmt.Println("x << 1 =", z)
z = x >> 1
fmt.Println("x >> 1 =", z)
}
Output
x & y = 1
x  y = 73
x ^ y = 72
x << 1 = 18
x >> 1 = 4
Read about Bitwise Operators in C here.
Miscellaneous Operators
 *: This operator provides a pointer to the variable.
 <: The name of this operator is received, which is used to receive a value from the channel.
 &: This operator returns the address of a variable.
Example
package main
import "fmt"
func main() {
a := 4
// Using address of operator(&) and
// pointer indirection(*) operator
b := &a
fmt.Println(*b)
*b = 7
fmt.Println(a)
}
Output:
4
7
Go Data Types
In Go programming, data types refer to a wide framework for declaring various types of variables and functions. A variable's type determines how much storage space it requires and how the stored bit pattern is interpreted.
Boolean
They are boolean types and consist of the two predefined constants: (a) true (b) false
Numeric
They are arithmetic types representing a) integer types or b) floatingpoint values throughout the program.
String
A string type is a collection of string values. Its value is a byte sequence. Strings are immutable types that are once created. It's not possible to change the contents of a string. The predeclared string type is a string.
Derived types
They include (a) Array types, (b) Pointer types, (c) Structure types, (d) Function types, and (e) Union types, f) Slice types g) Interface types h) Map types i) Channel Types
Let's discuss the mainly used data types in detail.
Integer Data Type
The predefined architectureindependent integer types are −
uint8 Unsigned 8bit integers (0 to 255)
uint16 Unsigned 16bit integers (0 to 65535)
uint32 Unsigned 32bit integers (0 to 4294967295)
uint64 Unsigned 64bit integers (0 to 18446744073709551615)
int8 Signed 8bit integers (128 to 127)
int16 Signed 16bit integers (32768 to 32767)
int32 Signed 32bit integers (2147483648 to 2147483647)
int64 Signed 64bit integers (9223372036854775808 to 9223372036854775807)
Floating Types
The predefined architectureindependent float types are −
float32 IEEE754 32bit floatingpoint numbers
float64 IEEE754 64bit floatingpoint numbers
complex64 Complex numbers with float32 real and imaginary parts
complex128 Complex numbers with float64 real and imaginary parts
Other Numeric Types
There is a set of numeric types with implementationspecific sizes −
byte Unsigned 8bit integers (0 to 255)
rune same as int32
uint 32 or 64 bits
int 32 or 64 bits
uintptr an unsigned integer to store the uninterpreted bits of a pointer value.
FAQs

What is the size of an int data type?
Ans: The size of the data types depends on the system.

What is the use of the assignment operator?
Ans: We use the assignment operator to assign values to a variable.

What is Boolean Data Type?
Ans: The boolean data type has two possible values, either true or false.
Key Takeaways
This article extensively discussed Datatypes & Operators topics and all the types in this article.
Here, you ought to have a better understanding of some of the most common data types available in Go. As you work on Go programming projects, these data types will become increasingly significant.
To study more about data types, refer to Abstract Data Types in C++.
"We hope that this blog enhances your knowledge regarding Datatypes & Operators, and if you would like to learn more about this, you can view *Data Types in C* . Do upvote our blog to help other ninjas grow. Happy Coding!"