Golang变量学习总结

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
)

iot 想得到与从0开始的给自增值，你要我们写写出表达式再复杂的枚举类型都可以使用这样的方式来定义常量。

总结

在Go语言的变量常量定义中，变量的类型标识是写的变量名的后边，编译器可以自动推测你需要定义变量的类型的，前提是你要初始化变量，没有 char 只有 rune ，原生态的支持复数这种类型。