 # Go Data Types

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.

## 1. Integer Data Type

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:

• signed integer `int` - can hold both positive and negative integers
• unsigned integer `uint` - can only hold positive integers

There 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.

### Example 1: Understanding Integer Type

``````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```

## 2. Float Data Type

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``````

### Example 2: Understanding Float Type

``````// 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```

## 3. String Data Type

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```````

### Example 3: Understanding String Type

``````// 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`

## 4. Boolean Data Type

The boolean data type has one of two possible values either `true` or `false`.

Keyword: `bool`

``var isValid bool``

### Example 4: Understanding bool Type

``````// Program to create boolean variables

package main
import "fmt"

func main() {
var boolValue bool
boolValue = false

fmt.Println(boolValue)
}``````

Output

`false`

We will learn about booleans in detail in the Go Comparison and Logical Operators tutorial.