> Go语言数据类型分为五种：
>
> + 布尔类型
> + 整型类型
> + 浮点类型
> + 字符类型
> + 字符串类型
>
> | **类型** | **名称** | **长度** | **零值** | **说明** |
> | --------- | -------- | -------- | -------- | --------------------------------------------- |
> | bool | 布尔类型 | 1 | false | 其值不为真即为假，不可以用数字代表true或false |
> | byte | 字节型 | 1 | 0 | uint8别名 |
> | int, uint | 整型 | - | 0 | 根据操作系统设定数据的值。 |
> | int8 | 整型 | 1 | 0 | -128 ~ 127 |
> | uint8 | 整型 | 1 | 0 | 0 ~ 255 |
> | int16 | 整型 | 2 | 0 | -32768 ~ 32767 |
> | uint16 | 整型 | 2 | 0 | 0 ~ 65535 |
> | int32 | 整型 | 4 | 0 | -2147483648 ~ 2147483647 |
> | uint32 | 整型 | 4 | 0 | 0 ~ 4294967295(42亿) |
> | int64 | 整型 | 8 | 0 | -9223372036854775808 ~ 9223372036854775807 |
> | uint64 | 整型 | 8 | 0 | 0 ~ 18446744073709551615(1844京) |
> | float32 | 浮点型 | 4 | 0.0 | 小数位精确到7位 |
> | float64 | 浮点型 | 8 | 0.0 | 小数位精确到15位 |
> | string | 字符串 | - | "" | utf-8字符串 |
### 1 布尔型
> 在计算机中，会涉及到逻辑性问题的真假对错，例如：在计算机中描述张三 ( 20岁 ) 比李四 ( 18岁 ) 小，这句话的结果？
>
> 布尔类型的变量取值要么是真（true）,要么是假 ( false )，用bool关键字来进行定义。
>
> 示例如下：
>
> ```go
> //定义bool类型变量
> var 变量名 bool = true
> ```
>
> ```go
> package main
> import "fmt"
>
> func main() {
> a := 10
> b := 20
> //比较两个数的大小 返回值为bool类型的结果
> fmt.Println(a > b) //false
> fmt.Println(a < b) //true
> //将表达式的结果赋值给bool类型变量c中
> var c bool = a < b
> fmt.Println(c)
> //格式化打印 使用占位符%t 输出一个bool类型数据
> fmt.Printf("%t", c)
> }
> ```
### 2 整型
> Go语言的整数类型一共有10个。
>
> 大多数情况下，我们只需要 int 一种整型即可，它可以用于循环计数器、数组和切片的索引，以及任何通用目的的整型运算符，通常 int 类型的处理速度也是最快的。
>
> 其中计算架构相关的整数类型有两个，即：
>
> + 有符号的整数类型 int。
> + 无符号的整数类型 uint。
>
> ```go
> //有符号的整型
> var a int = -10
> //无符号的整型(不可以存储带符号数据)
> var b uint = 10
>
> //格式化打印 使用占位符%d 输出一个int类型数据
> fmt.Printf("%t", a)
> ```
>
> 这两个计算架构相关的整数类型之外，还有8个可以显式表达自身宽度的整数类型。
>
> 如下表所示。
>
> | **数据类型** | **有符号** | **类型长度**（位） | 取值范围 |
> | ------------ | :--------: | :----------------: | :----------------------------------------- |
> | int8 | 是 | 8 | -128 ~ 127 |
> | int16 | 是 | 16 | -32768 ~ 32767 |
> | int32 | 是 | 32 | -2147483648 ~ 2147483647 |
> | int64 | 是 | 64 | -9223372036854775808 ~ 9223372036854775807 |
> | uint8 | 否 | 8 | 0 ~ 255 |
> | uint16 | 否 | 16 | 0 ~ 65535 |
> | uint32 | 否 | 32 | 0 ~ 4294967295 |
> | uint64 | 否 | 64 | 0 ~ 18446744073709551615 |
>
>
> 可以看到，这8个整数类型的宽度已经表现在它们的名称中了。
### 3 浮点型
> Go语言提供了两种精度的浮点数 float32 和 float64。
>
> 这些浮点数类型的取值范围可以从很微小到很巨大。浮点数取值范围的极限值可以在 math 包中找到：
>
> - 常量 math.MaxFloat32 表示 float32 能取到的最大数值，大约是 3.4e38；
> - 常量 math.MaxFloat64 表示 float64 能取到的最大数值，大约是 1.8e308；
> - float32 和 float64 能表示的最小值分别为 1.4e-45 和 4.9e-324。
>
> 浮点型数据都是相对精准的，存在一定的误差值：
>
> + float32 类型的浮点数可以提供约 6 个十进制数的精度。
> + float64 类型的浮点数可以提供约 15 个十进制数的精度。
>
> 通常应该优先使用 float64 类型，因为 float32 类型的累计计算误差很容易扩散，并且 float32 能精确表示的正整数并不是很大。
> 浮点数在声明的时候可以只写整数部分或者小数部分，像下面这样：
>
> ```go
> const e = .71828 // 0.71828
> const f = 1. // 1.0
> ```
>
> 很小或很大的数最好用科学计数法书写，通过 e 或 E 来指定指数部分：
>
> ```go
> const Avogadro = 6.02214129e23 // 阿伏伽德罗常数
> const Planck = 6.62606957e-34 // 普朗克常数
> ```
>
> 用 Printf 函数打印浮点数时可以使用“%f”来控制保留几位小数
>
> ```go
> package main
> import "fmt"
>
> func main() {
> pi := 3.1415926
> //格式化打印 使用占位符%d 输出一个float类型数据
> //%f 默认保留六位小数 会四舍五入
> fmt.Printf("%f\n", Pi)
> //设置保留二位小数
> fmt.Printf("%.2f\n", Pi)
> }
> ```
### 4 字符型
> Go语言的字符有以下两种：
>
> - 一种是 uint8 类型，或者叫 byte 型，代表了 **ASCII码** 的一个字符。
> - 一种是 rune 类型，代表一个 UTF-8 字符，当需要处理中文、日文或者其他复合字符时，则需要用到 rune 类型。
>
> byte 类型是 uint8 的别名，对于只占用 1 个字节的传统 ASCII 编码的字符来说，完全没有问题，
>
> 例如：
>
> ```go
> //字符类型是用单引号括起来的单个字符
> var ch byte = 'A'
> //格式化打印 使用占位符%c 输出一个byte类型数据
> fmt.Printf("%c\n", ch)
> ```
>
> rune 类型等价于 int32 类型，可以存储带中文的符合字符。
>
> 例如：
>
> ```go
> //rune 类型可以存储带中文的字符
> var ch rune = '帅'
> //格式化打印 使用占位符%c 输出一个rune类型数据
> fmt.Printf("%c\n", ch)
> ```
### 5 字符串型
> 用双引号括起来的字符是字符串类型 。
>
> 在Go中的字符串，都是采用UTF-8字符集编码。
>
> ```go
> var str string = "法师真帅"
> //格式化打印 使用占位符%s 输出一个string类型数据
> fmt.Printf("%s\n", ch)
> ```
>
> **字符串拼接**
>
> ```go
> str1 := "性感法师"
> str2 := "在线讲课"
> fmt.Println(str1 + str2) //性感法师在线讲课
> ```
>
> **字符串长度**
>
> ```go
> str1 := "hello"
> str2 := "法师"
> //len(字符串) 计算字符串中字符个数
> fmt.Println(len(str1)) //5
> fmt.Println(len(str2)) //6 一个汉字占三个字符
> ```
有疑问加站长微信联系（非本文作者））
