In this article, We are going to learn about data type in go golang. All the variables in go golang has an associate type.
Data type defines how the data is stored in memory, what is the possible value for that particular data type and what kind of operations we can perform in go golang.
While using any built-in data type, there is no need to import any package.
Data types are divided into 4 main categories which are as follows:
- Basic data type
- Aggregate data type
- Reference type
- Interface type
Basic data type
Basic data types are divided into 3 sub-categories which are as follows:
- Number
- string
- boolean
Numbers:
Numeric data types are used to represent numbers. Further, Numbers are divided into 3 sub-categories which are as follows:
- integer numeric data type
- floating-point numeric data type
- complex numeric data type
1:) integer numeric data type:
There are 11 built-in integer numeric types.
Data Type | Size | Range |
int8 | Signed 8-bit integers | -128 to 127 |
uint8 | Unsigned 8-bit integers | 0 to 255 |
int16 | Signed 16-bit integers | -32768 to 3276 |
uint16 | Unsigned 16-bit integers | 0 to 65535 |
int32 | Signed 32-bit integers | -2147483648 to 2147483647 |
uint32 | Unsigned 32-bit integers | 0 to 4294967295 |
int64 | Signed 64-bit integers | -9223372036854775808 to 9223372036854775807 |
uint64 | Unsigned 64-bit integers | 0 to 18446744073709551615 |
int | 32 / 64 bits (based on architectures ) | |
uint | 32 / 64 bits (based on architectures ) |
uintptr numeric data type: It is an unsigned integer type. Its width is not defined, but its can hold all the bits of a pointer value.
Go also support two built-in data type aliases.
- byte data type is a alias of uint8.
- rune is a built-in alias of int32
Example with code:
// Go program to explain the use of integers
package main
import "fmt"
func main() {
// Using 8-bit unsigned int
var x uint8 = 225
fmt.Println(x+1, x)
// Using 16-bit signed int
var y uint16 = 220
fmt.Println(y+2, y-2)
}
Output:
226 225
222 218
2:) floating-point numeric data type:
A floating-point number or a float is used to represent real numbers that cannot be expressed as integers.
There are two built-in floating-point numeric types.
- float32 : 32-bit floating-point numbers
- float64 : 64-bit floating-point numbers
Example with code:
// Go program to explain the use of floating-point numbers
package main
import "fmt"
func main() {
x := 10.12
y := 22.12
// Subtraction of two floating-point number
z := x - y
// Display the result
fmt.Printf("Result is: %f", z)
// Display the type of c variable
fmt.Printf("\nThe type of z is : %T", z)
}
Output:
Result is: -12.000000
The type of z is : float64
3:) complex numeric data type:
There are two built-in complex numeric types.
- complex64 – Complex numbers with float32 real and imaginary parts
- complex128 – Complex numbers with float64 real and imaginary parts
Operations on complex numbers:
You can perform arithmetic operations like addition, subtraction, multiplication, and division on complex numbers.
Example:
var x = 5 + 7i // Type inferred as `complex128`
Go provides a built-in function named complex for creating complex numbers.
Example of complex number with code:
// Go program to explain the use of complex numbers
package main
import "fmt"
func main() {
var x complex128 = complex(5, 3)
var y complex64 = complex(11, 4)
fmt.Println(x)
// Display the type
fmt.Printf("The type of x is %T and "+ "the type of y is %T", x, y)
}
Output:
(5+3i)
The type of x is complex128 and the type of y is complex64
Note: Both real and imaginary parts of the complex number must be of the same floating point type.
string data type:
A string is a sequence of one or more characters (letters, numbers, symbols) that can be either a constant or a variable.
You can assign string to variable by back quote (`) or double quote(“”) in go golang. If you use the back quotes, you are creating a raw string literal. If you use the double quotes, you are creating an interpreted string literal.
Example of string data type using code:
// Go program to explain the use of strings
package main
import "fmt"
func main() {
// Raw String Literals
x := `Say "hello" to Golang!`
fmt.Println(x)
x = `Say "hello" to Golang!\n`
fmt.Println(x)
x = `This string is on
multiple lines
within a single back
quote on either side.`
fmt.Println(x)
// Interpreted String Literals
x = "Say \"hello\" to Golang!"
fmt.Println(x)
}
Output:
Say "hello" to Golang!
Say "hello" to Golang!\n
This string is on
multiple lines
within a single back
quote on either side.
Say "hello" to Golang!
boolean data type:
The boolean data type can be one of two values either true or false and is defined as bool when declaring it as a data type. We can not convert values of type boolean to any other type implicitly or explicitly.
Syntax:
var var_name bool
Example of bool data type with code:
// Go program to explain the use of boolean data type
package main
import "fmt"
func main() {
str1 := "Techieindoor"
str2:= "Techieindoor"
str3:= "TechieInDoor"
result1:= str1 == str2
result2:= str1 == str3
// Display the result
fmt.Println( result1)
fmt.Println( result2)
// Display the type of result1 and result2
fmt.Printf("The type of result1 is %T and "+
"the type of result2 is %T",
result1, result2)
}
Output:
true
false
The type of result1 is bool and the type of result2 is bool
Aggregate data type
Array types and structure types are collectively referred to as aggregate types.
To learn about structure , Please refer this link:
Structure data type
Reference data type
Pointers, slices, maps, functions and channels come under this category.
Interface type
Type Conversion:
Golang has strong type system. You can not mix numeric types in an expression. For example, You cannot add an int variable to a float64 variable or even an int variable to an int64 variable. You cannot even perform an assignment between mixed types.
Example:
var x int64 = 10
var y int = x // Compiler Error (Cannot use x (type in64) as type int in assignment)
var z int = 200
var result = x + z // Compiler Error (Invalid Operation: mismatched types int64 and int)
References:
https://www.tutorialspoint.com/go/go_data_types.htm
https://www.geeksforgeeks.org/data-types-in-go/
https://www.digitalocean.com/community/tutorials/understanding-data-types-in-go
To learn more about golang, Please follow given below link:
https://techieindoor.com/go-lang-tutorial/