Golang里面变量总的来说分四大类型
1. bool，string
bool：指布尔类型，也就是true, false
string: 字符串类型
2. (u)int, (u)int8, (u)int16, (u)int32, (u)int64, uintptr
int 和 uint, 其中有u和没有u指的是unsigned指的是有无符号，也就是有无正负号，int类型会根据你操作系统的字数来判断是32位还是64位，如果你的操作系统是64位的，那么在定义int的时候就是64位，也就是你定义int的时候编译器会根据你的操作系统来给这个变量自动分配多大的空间大小。
(u)int8, (u)int16, (u)int32, (u)int64这些后面的8, 16, 32, 64这些是指你定义的变量的大小，8 就是8位，这里的8位指的是二进制中的8位，同理16, 32, 64也是一样的道理，位数越多，变量能便是的范围越大。
uintptr是指针类型，Go语言也是具有指针这一特性的，但是并没有像c语言使用那么的复杂。后会深究这个类型。
3. byte, rune
byte类型你可以看作是uint8的一个别名，byte和uint8表示的范围是一样的，也可以叫做字节类型，byte,最大能表示的范围也就是一个字节的空间大小。
rune是一个新的数据类型，因为你在其他的语言中并没有见过这种类型，相对来说也比较陌生，但是我举个例子你就能完全明白了，在c语言中，有char这个类型，是用来便是一个ASCII字符的，但是是随着编程知识的普及，很多国家的人们都在学习编程，编写程序，但是语言就成为来一大障碍，仅仅用ASCII编码是远远不能满足人们的需求的，故Go语言就是用了Unicode编码，rune也就相当于是在Unicode编码下的字符类型。
rune的长度是32位的，我们都知道unicode是2字节的，但是互联网中很多时候都是使用的UTF-8编码，所以我们rune类型采用了4字节的存储空间，如果后期Go会升级成UTF-8编码提供了可能。
在c语言中，我们都知道char是可以和整型混用的，举个例子：printf("%c",97);输出的是小写字母a。那么rune类型也是可以类似的使用的。
4. float32, float64, complex64, complex128
float32和float64都是浮点数类型，float32大约可以提供小数点后6位的精度，作为对比，float64可以提供小数点后15位的精度。如果想探究浮点数在计算机中的存储形式可以百度一下。
complex64和complex128就是用来表示我们数学中的复数，复数实部和虚部，complex64的实部和虚部都是32位float，complex128的实部和虚部都是64位float。
Golang的变量定义方式
package main
import "fmt"
var bb uint8 = 12
var xx = 12
var (
cc = 12
q, w = 12, 12
b string = "false"
)
func variableZoreValue() {
var a int
var b string
fmt.Println(a, b)
}
func variableInitialValue() {
var a int = 1
n, x := 1, 2
var s string = "abc"
fmt.Println(a, s)
fmt.Println(n, x)
}
func main() {
variableZoreValue()
variableInitialValue()
fmt.Println(bb, xx, cc, q, w, b)
}
我们定义的变量可以在函数内也可以在函数外，在函数外部定义的变量并不是全局变量，应该是叫做包内变量，因为是在一个包下面。
定义一个变量：
var a int这种定义方式指明了变量的类型，没有初始化，但是我们的编译器会帮你初始化为0
var a int = 16这种方式是相比上一种方式多了初始化。
var a = 12这种方式没有指定类型，但是初始化了一个值12，这种方式编译器会自动的识别是那种类型，就像python里面一样，不需要指定类型。
a := 12这种方式和上一种类似，但是更加方便，不用写前面的var了。
定义多个变量
var bb,cc uint8 = 12, 13这种方式可以定义多个相同类型的变量
var z, str = 14, "string"这种方式比上一种方式更好好用，因为这样可以同时定义多个不同类型的数据了。
n, x := 1, 2这种方式比上一种方式更加方便，不仅可以同时定义多个不同类型的变量同时不用写var关键字了。
complex 复数类型
package main
import (
"fmt"
"math/cmplx"
"math"
)
func complexVariable() {
c := 3 + 4i
fmt.Println("|3 + 4i|=",cmplx.Abs(c))
fmt.Println(cmplx.Pow(math.E, 1i * math.Pi) + 1)
fmt.Println(cmplx.Exp(1i * math.Pi) + 1)
fmt.Printf("%0.3f", cmplx.Exp(1i * math.Pi) + 1)
}
func main() {
complexVariable()
}
c := 3 + 4i,我们在定义复数的时候应该是这种形式而不是：c := 3 + 4*i，如果是这样的形式，则编译器会把这个i当作是变量处理，而不是复数标志
cmplx.Abs(c),取复数的绝对值
cmplx.Pow(math.E, 1i * math.Pi) + 1，计算e^(iπ)+1,e是数学中的自然数。
cmplx.Exp(1i * math.Pi) + 1,另外一种计算方式
fmt.Printf("%0.3f", cmplx.Exp(1i * math.Pi) + 1)格式化输出复数。
常量的定义
package main
import (
"fmt"
"math"
)
c consts() {
var filename = "1.txt"
const a, b = 3, 4
var c int = 0
c = int(math.Sqrt((a*a + b*b)))
fmt.Println(filename, c)
}
func main() {
consts()
}
Go语言中的常量是和c语言中的宏常量是一样的，本着替换的原则，所以如果在定义常量的时候编译器不用指定类型，所以在c = int(math.Sqrt((a*a + b*b)))中就不用把(a*a + b*b)强转为float64。
在定义变量的规则中对常量也是适用的，我就不多讲了，自己去实践下就知道了。
定义枚举类型
在Go语言中并没有针对枚举类型的关键字的，那Go语言是怎么定义枚举类型的呢？
package main
import "fmt"
func enums() {
const(
c = 0
cpp = 1
java = 2
python = 3
)
fmt.Println(c, cpp, java, python)
}
func main() {
enums()
}
这样我们便定义了一个枚举同时还可以使用iota关键字，表示这个枚举类型是递增的
package main
import "fmt"
func enums() {
const(
c = iota
cpp
java
python
)
fmt.Println(c, cpp, java, python)
}
func main() {
enums()
}
更高级的定义方法：
// 定义b kb mb gb tb pb
const(
b = 1 << (10 * iota)
kb
mb
gb
tb
pb
)
iota想得到与从0开始的给自增值，你要我们写写出表达式再复杂的枚举类型都可以使用这样的方式来定义常量。我们可以输出一下我们定义的枚举类型看一下。
package main
import (
"fmt"
)
func test() {
const(
b = 1 << (10 * (iota))
kb
mb
gb
tb
pb
)
fmt.Println(b, kb, mb, gb, tb, pb)
}
func main() {
test()
}
通过输出结果可以总结得到其实iota是一个会从0开始自增的一个值，可以深入底层代码查看iota本质上就是为0的常量变量
// iota is a predeclared identifier representing the untyped integer ordinal
// number of the current const specification in a (usually parenthesized)
// const declaration. It is zero-indexed.
const iota = 0 // Untyped int.
总结
在Go语言的变量常量定义中，变量的类型标识是写的变量名的后边，编译器可以自动推测你需要定义变量的类型的，前提是你要初始化变量，没有
char只有rune，原生态的支持复数这种类型。
