- brief introduction
- integer
- Floating point type
- Boolean
- complex

## brief introduction

In the definition of variables, we said that each variable has a type, and the type is used to restrict the interpretation of data in the computer. Like other computer languages, go language provides a wealth of data types. Let’s see what types there are and compare them with other languages.

## integer

Integer is the type used to indicate that the variable is an integer. and`C`

similar,`Go`

Integer types are divided into two categories: unsigned and signed. Signed is simply a type that can represent negative numbers. Unsigned is this type, which has no sign and uniformly represents integers. Besides symbols, there is also length, because symbols and length determine the range of integers. Here is`Go`

Classification of integers:

type | explain | Range |
---|---|---|

int | Integer. The length is related to the byte size of the platform machine, usually 32 or 64 bits | Related to bytecode |

uint | Unsigned integer, the length is related to the byte size of the platform machine, generally 32 or 64 bits | Related to bytecode |

int8 | Signed 8-bit integer | -128 ~ 127 |

uint8 | Unsigned 8-bit integer | 0 ~ 255 |

int16 | Signed 16 bit integer | -32768 ~ 32767 |

uint16 | Unsigned 16 bit integer | 0 ~ 65535 |

int32 | Signed 32-bit integer | -2147483648 ~ 2147483647 |

uint32 | Unsigned 32-bit integer | 0 ~ 4294967295 |

int64 | Signed 64 bit integer | -9223372036854775808 ~ 9223372036854775807 |

uint64 | Unsigned 64 bit integer | 0 ~ 18446744073709551615 |

## Floating point type

`Go`

There are two floating point types,`float32`

and`float64`

, they all match`IEEE754`

Definition of specifications. When it comes to floating point types, we have to mention precision,`float32`

Approximately 6-bit accuracy error is provided, and`float64`

Provides an accuracy error of about 15 bits.

For example, the following code:

```
package main
import "fmt"
func main() {
var i float32 = 10
var j float32 = 10.0000000001
var m float64 = 10
var n float64 = 10.0000000001
fmt.Println(i == j)
fmt.Println(m == n)
}
```

Printed are:

```
true
false
```

Therefore, attention should be paid to the problem of accuracy in normal use. In addition to directly using decimal form, scientific counting method can also be used, such as

`var i float32 = 10e-2 // 0.01`

## Boolean

There are two Boolean types:`true`

and`false`

, usually used for logical judgment

## complex

The complex number is not often used. In the mathematical definition, the complex number has real part and imaginary part.`Go`

Two precision complex types are provided,`complex64`

and`complex128`

They correspond to each other`float32`

and`float64`

Accuracy.

```
var x complex128 = complex(1, 2) // 1+2i
var y complex128 = complex(3, 4) // 3+4i
i := 1 + 2i
j := 3 + 4i
```

The above is the writing of plural numbers. Just specify their real and imaginary parts respectively. Plural numbers can also be compared for equality

```
i := 1 + 2i
j := 1 + 3i
fmt.Println(i == j)
```

But the real part and imaginary part must be the same`true`