Go语言的基本类型有：整形、浮点型、布尔型、字符串，还有切片、结构体、函数、map、通道等。
整形
整形分为以下两大类
- 按长度分为：int8，int16，int32，int64
- 对应的无符号整型：uint8，uint16，uint32，uint64.
其中uint8就是byte类型，int16对应c中的short型，int64对应c语言中的long型。
自动匹配平台的int和uint
Go语言有自动匹配特定平台整形长度的类型-int和uint。
在使用int和uint时，不能假定它是32位和64位的整形，而是考虑int和uint可能在不同平台上的差异。
那些情况下使用int和uint
逻辑对整型范围没有特殊要求时使用。
在二进制传输，读写文件的结构描述时，为了保持文件的结构不会收到不同编译目标平台字节长度的影响，不要使用int和uint。
浮点型
Go语言提供了两种精度的浮点数 float32 和 float64
这些浮点数类型的取值范围可以从很微小到很巨大。浮点数取值范围的极限值可以在 math 包中找到：
- 常量 math.MaxFloat32 表示 float32 能取到的最大数值，大约是 3.4e38；
- 常量 math.MaxFloat64 表示 float64 能取到的最大数值，大约是 1.8e308；
- float32 和 float64 能表示的最小值分别为 1.4e-45 和 4.9e-324。
浮点数会有一个精度的限制。所以应该优先使用float64，比如以下程序
package main
import "fmt"
func main() {
var f float32 = 1677721666 // 1 << 24
fmt.Println(f)
fmt.Println(f + 1)
fmt.Println(f == f+1) // "true"!
}
结果：
1.6777217e+09
1.6777217e+09
true
会有精度的丢失，输出结果为true
使用float64则正常
package main
import "fmt"
func main() {
var f float64 = 1677721666 // 1 << 24
fmt.Println(f)
fmt.Println(f + 1)
fmt.Println(f == f+1) // "true"!
}
结果：
1.677721666e+09
1.677721667e+09
false
浮点数在声明的时候可以只写整数部分或者小数部分
package main
import "fmt"
func main() {
const e = .71828 // 0.71828
const f = 1. // 1
fmt.Println(e, f)
}
结果：
0.71828 1
可以使用科学记数法记录很小或者很大的数，通过e或来制定指数部分。
const Avogadro = 6.02214129e23 // 阿伏伽德罗常数
const Planck = 6.62606957e-34 // 普朗克常数
fmt.Println(e, f)
fmt.Println(Avogadro, Planck)
结果：
6.02214129e+23 6.62606957e-34
用 Printf 函数打印浮点数时可以使用“%f”来控制保留几位小数
package main
import (
"fmt"
"math"
)
func main() {
fmt.Printf("%f\n", math.Pi)
fmt.Printf("%.2f\n", math.Pi)
}
结果：
3.141593
3.14
复数
在计算机中，复数是由两个浮点数表示的，其中一个表示实部（real），一个表示虚部（imag）。
Go语言中复数的类型有两种，分别是 complex128（64 位实数和虚数）和 complex64（32 位实数和虚数），其中 complex128 为复数的默认类型。
复数的值由三部分组成 RE + IMi，其中 RE 是实数部分，IM 是虚数部分，RE 和 IM 均为 float 类型，而最后的 i 是虚数单位。
复数的声明
package main
import "fmt"
func main() {
var a complex128 = complex(6, 9)
fmt.Println(a)
}
结果：
(6+9i)
也可以通过下面的方式申请
b := complex(9, 8)
fmt.Println(b)
fmt.Println(real(b))
fmt.Println(imag(b))
对于一个复数z := complex(x, y)，可以通过Go语言的内置函数real(z) 来获得该复数的实部，也就是 9；通过imag(z) 获得该复数的虚部，也就是 8。
复数也可以用==和!=进行相等比较，只有两个复数的实部和虚部都相等的时候它们才是相等的。
布尔型
布尔型数据在Go语言中意bool类型进行声明，布尔类型数据只有ture和false两个值
一元操作符!对应逻辑非操作，因此!true的值为 false
package main
import "fmt"
func main() {
var a int = 5
var b int = 10
fmt.Println(a != b)//true
}
布尔值可以和 &&（AND）和 ||（OR）操作符结合，并且有短路行为，如果运算符左边的值已经可以确定整个布尔表达式的值，那么运算符右边的值将不再被求值
&&的优先级高于 ||
布尔型无法参与数值运算，也无法与其他类型进行转换
字符串
字符串在Go语言中以原生数据类型出现，使用字符串就像使用其他原生数据类型一样。
字符串的值为双引号的内容，可以在Go语言的源码中直接添加非ASCII码字符，代码如下：
import "fmt"
func main() {
str := "hello go"
ch := "中文"
fmt.Println(str, ch)
}
字符串转义符
| 转移符 | 含义 |
|---|---|
| \r | 回车符 |
| \n | 换行符 |
| \t | 制表符 |
| ’ | 单引号 |
| " | 双引号 |
| \ | 反斜杠 |
fmt.Println("str=\"c:\\go\\bin\\go.exe\"")
结果：
str="c:\go\bin\go.exe"
可以使用``括起来多行字符串，进行原样输出。
在`间的所有代码都不会被编译器识别，而是作为字符串的一部分。
字符
字符串中的每一个元素叫做“字符”，在遍历或者单个获取字符串元素时可以获得字符。
Go语言的字符有以下两种：
- 一种是 uint8 类型，或者叫 byte 型，代表了 ASCII 码的一个字符。
- 另一种是 rune 类型，代表一个 UTF-8 字符，当需要处理中文、日文或者其他复合字符时，则需要用到 rune 类型。rune 类型等价于 int32 类型。
byte 类型是 uint8 的别名，对于只占用 1 个字节的传统 ASCII 编码的字符来说，完全没有问题，例如 var ch byte = ‘A’，字符使用单引号括起来
使用fmt.Printf中的“%T”动词可以输出变量的实际类型
package main
import "fmt"
func main() {
var a byte = 'a'
var b rune = '你'
fmt.Printf("%d, %T \n", a, a)
fmt.Printf("%d, %T", b, b)
}
结果：
97, uint8
20320, int32