We use data types in Golang to determine the type of data associated with variables. For example,
var age int
Here, int
is a data type that specifies that the age
variable can store integer data.
The basic data types in Golang are
Data Types | Description | Examples |
---|---|---|
int | Integer numbers. | 7123 , 0 , -5 , 7023 |
float | Numbers with decimal points. | 20.2 , 500.123456 , -34.23 |
complex | Complex numbers. | 2+4i , -9.5+18.3i |
string | Sequence of characters. | "Hello World!" , "1 is less than 2" |
bool | Either true or false. | true , false |
byte | A byte (8 bits) of non-negative integers. | 2 , 115 , 97 |
rune | Used for characters. Internally used as 32-bit integers. | 'a' , '7' , '<' |
Now, let's discuss the commonly used data types in detail.
Integers are whole numbers that can have both zero, positive and negative values but no decimal values. For example, 0
, 5
, -1340
.
We commonly use the int
keyword to declare integer numbers.
var id int
Here, id is a variable of type integer.
You can declare multiple variables at once in the same line.
var id, age int
In Go programming, there are two types of integers:
int
- can hold both positive and negative integersuint
- can only hold positive integersThere are different variations of integers in Go programming.
Data type | Size |
---|---|
int/uint | either 32 bits (4 bytes) or 64 bits (8 bytes) |
int8/uint8 | 8 bits (1 byte) |
int16/uint16 | 16 bits (2 bytes) |
int32/uint32 | 32 bits (4 bytes) |
int64/uint64 | 64 bits ( 8 bytes) |
Note: Unless we have a specific requirement, we usually use the int keyword to create integers.
package main
import "fmt"
func main() {
var integer1 int
var integer2 int
integer1 = 5
integer2 = 10
fmt.Println(integer1)
fmt.Print(integer1)
}
Output
5
10
The float type is used to hold values with decimal points. For example, 6.7
, -34.2
Keywords used: float32
, float64
Here's an example,
var salary float64
There are two sizes of floating-point data in Go programming.
Data Type | Size |
---|---|
float32 | 32 bits (4 bytes) |
float64 | 64 bits (8 bytes) |
Note: If we define float variables without specifying size explicitly, the size of the variable will be 64 bits. For example,
// the size of the variable is 64
salary := 5676.3
// Program to illustrate float32 and float64 with example
package main
import "fmt"
func main() {
var salary1 float32
var salary2 float64
salary1 = 50000.503882901
// can store decimals with greater precision
salary2 = 50000.503882901
fmt.Println(salary1)
fmt.Println(salary2)
}
Output
50000.504
50000.503882901
A string is a sequence of characters. For example, "Hello"
, "Hey there"
Keyword: string
Here's an example,
var message string
In Go, we use either double quotes or backticks to create strings.
var message string = "Hello World "
var message string = `Hello World`
// Program to create string variables
package main
import "fmt"
func main() {
var message string
message = "Welcome to Programiz"
fmt.Println(message)
}
Output
Welcome to Programiz
The boolean data type has one of two possible values either true
or false
.
Keyword: bool
var isValid bool
// Program to create boolean variables
package main
import "fmt"
func main() {
var boolValue bool
boolValue = false
fmt.Println(boolValue)
}
Output
false