# Data Types

## Introduction

Go is statically typed, meaning variables always have a specific type and that type cannot change.

Data Type for a variable defines:

* The amount of memory space allocated for variables.
* A data type specifies the possible values for variables.
* The operations that can be performed on variables.

Go built-in data types:

* Numbers
* Boolean 
* String

### Integer

#### Signed integers

| Type    | Size               | Description (Two's complement)                                                        |
| ------- | ------------------ | ------------------------------------------------------------------------------------- |
| int8    | 8 bits             | 8 bit signed integer                                                                  |
| int16   | 16 bits            | 16 bit signed integer                                                                 |
| int32   | 32 bits            | 32 bit signed integer                                                                 |
| int64   | 64 bits            | <p>64 bit signed integer, </p><p>can also be represented in octal and hexadecimal</p> |
| **int** | Platform dependent | signed integers of at least 32-bit in size, not equivalent to int32.                  |

#### Unsigned integers

| Type   | Size               | Description (Two's complement)                                         |
| ------ | ------------------ | ---------------------------------------------------------------------- |
| uint8  | 8 bits             | 8 bit unsigned integer                                                 |
| uint16 | 16 bits            | 16 bit unsigned integer                                                |
| uint32 | 32 bits            | 32 bit unsigned integer                                                |
| uint64 | 64 bits            | 64 bit unsigned integer                                                |
| uint   | Platform dependent | unsigned integers of at least 32-bit in size, not equivalent to int32. |

{% hint style="info" %}
Use **int** unless for specific reasons for others. Integral types have default value of 0. Octal numbers can be declared using prefix and hexadecimal using the **0x** prefix.
{% endhint %}

#### Other integer types

| Type    | Description (Two's complement)                                         |
| ------- | ---------------------------------------------------------------------- |
| byte    | It is alias for and equivalent to uint8                                |
| rune    | It is alias for and equivalent to int32, used to represent characters. |
| uintptr | It is used to hold memory address pointers                             |

{% hint style="info" %}
Golang does not support a char data type, instead it has **byte** and **rune** to represent character values. This helps to distinguish characters from integer values. **byte** data type is represented with a ASCII value and the **rune** data type is represented with Unicode value encoded in UTF-8 format.
{% endhint %}

```go
package main
import "fmt"
 
func main() {
 var varByte byte = 'a' // ASCII value of 97
 var varRune rune = '♥' // Unicode value of U+2665
 
 fmt.Printf("%c = %d and %c = %U\n", varByte, varByte, varRune, varRune)
}
```

```bash
a = 97 and ♥ = U+2665
```

#### Float

Go supports float32 and float64 represented with 32-bit and 64-bit in memory respectively.

```go
var num1 float32 = 20.0320
var num2 = 20.0818 // Type inferred as float64
```

#### Complex Numbers

Go supports complex64 and complex128. Each of the type uses float32 and float64 respectively, to represent their real and imaginary parts.

```go
var num1 = 3 + 7i  // Type inferred as complex128
```

###

### Boolean

```go
var flag = true
```

###

### String

```go
// No newlines, and can contain escape sequences like \n, \t
var fstr="Hello World"
 
// Can span multiple lines. Escape characters are not allowed.
var sstr= `Hello world, this
a multi-line text string.`
```

## Type Conversions

#### Syntax: The expression `T(v)` converts the value `v` to the type `T`.

```go
var i int = 42
var f float64 = float64(i)
var u uint = uint(f)
```

```go
// short syntax
i := 42
f := float64(i) // 42.000000
u := uint(f)
```

## Type Inference

When declaring a variable without specifying an explicit type (either by using the `:=` syntax or `var =` expression syntax), the variable's type is inferred from the value on the right hand side.

```go
package main

import "fmt"

func main() {
	i := 42
	f := 12.0212
	c := 0.5 + 2i
	fmt.Printf("i is of type %T\n", i)
	fmt.Printf("f is of type %T\n", f)
	fmt.Printf("c is of type %T\n", c)
}
```

```bash
i is of type int
f is of type float64
c is of type complex128
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://blog.yushunchen.com/golang-notes/basics/data-types.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.