Golang 学习之路四：类型

Golang学习：类型

一、变量

　　Go语言静态类型，在运行期间是不能改变变量的类型的。下面会介绍变量的使用。

1.使用关键字var定义变量，如果后面未接初始化值会自动初始化为零值，也可以省略变量的类型由编译器自动推断。

var n int
var f float32 = 1.6
var s = "abc"

2.在函数内部，可以使用更加简略的”:=”来进行定义变量。注意这里指的是定义变量，并不是修改，因此注意实在函数内部使用。

func main(){
    a := 123
}

3.可以一次定义多个变量。可以将它们写进var()中或使用多变量赋值。使用var对相同类型的变量定义时可以只写一次。

var c int, d int
var p, q int
var (
a int
b float32
)
func main() {
n, s := 0x1234, "Hello, World!"
println(x, s, n)
}

4.使用’-‘当作变量名，用于忽略值占位。

func test() (int, string) {
return 1, "abc"
}
func main() {
_, s := test()
println(s)
}

注意：

• 局部变量定义而未使用的话，编译的时候会报错，而全局变量并不会报错。

var s string // s 是全局变量不会报错。
func main() {
i := 0 // Error: i declared and not used。(可使⽤用 "_ = i" 规避)
}

• 注意重新赋值与定义新同名变量的区别，在同一代码块使用‘:=’是重新赋值，而不再同一代码块则为定义。

s := "abc"
println(&s)
s, y := "hello", 20 // 重新赋值: 与前 s 在同⼀一层次的代码块中，且有新的变量被定义。
println(&s, y) // 通常函数多返回值 err 会被重复使⽤用。
{
s, z := 1000, 30 // 定义新同名变量: 不在同⼀一层次代码块。
println(&s, z)
}

二、常量

　　变量的值必须编译器可确定数字、字符串、布尔值。它是用’const’作为关键字的，声明时用法和’var’非常相似。但是注意不能出现只声明而不赋值的情况。

const x, y int = 1, 2 // 多常量初始化
const s = "Hello, World!" // 类型推断
const ( // 常量组
a, b = 10, 100
c bool = false
)
func main() {
const x = "xxx" // 未使⽤用局部常量不会引发编译错误。
}

• 在常量组，如不类型或初始化值，它与前一个常量相同

const (
a = 123
b               // b = 123
)

• 常量值可以是 len、cap、unsafe.Sizeof 等编译期可确定结果的函数返回值

const (
a = "abc"
b = len(a)
c = unsafe.Sizeof(b)   // 查看变量所占字节数
)

• 注意溢出

const (
a byte = 100 // int to byte
b int = 1e20 // float64 to int, overflows
)

枚举
- 关键字 iota 定义常量中从 0 开始计数的自增枚举值

const (
    Sunday = iota   // 0
    Monday          // 1，通常省略后续行表达式。
    Tuesday         // 2
    Wednesday       // 3
    Thursday        // 4
    Friday          // 5
    Saturday        // 6
)

const (
    _        = iota             // iota = 0
    KB int64 = 1 << (10 * iota) // iota = 1
    MB                          // 与 KB 表达式相同，但 iota = 2
    GB
    TB
)

注意MB是和KB有相同的表达式，但是iota在加一，下面的依次类推。输出的结果：

KB: 1024
MB: 1048576
GB: 1073741824
TB: 1099511627776

• 在同一常量组中，可以提供多个 iota，它们各自增长。

const (
    A, B = iota, iota << 10    // 0, 0 << 10
    C, D                       // 1, 1 << 10
)

• 如果 iota ⾃自增被打断，须显式恢复。注意打断过程中枚举仍然在计数。

const (
A = iota    // 0
B           // 1
C = "c"     // c
D           // c，与上⼀⾏相同。
E = iota    // 4，显式恢复。注意计数包含了 C、D 两行。
F           // 5
)

• 可通过自定义类型来实现枚举类型限制。注意下面实例Error的地方。不可以用一个变量，只可以用定义类型常量或type等值常量编译器会对其进行转换。

type Color int
const (
    Black Color = iota
    Red
    Blue
)
func test(c Color) {}
func main() {
    c := Black
    test(c)
    x := 1
    test(x)  // Error: cannot use x (type int) as type Color in function argument
    test(1)  // 常量会被编译器自动转换。
}

三、基本类型

1. 整数

　　Go语言的整数类型一共有10个。
　　其中计算架构相关的整数类型有两个，即：有符号的整数类型int和无符号的整数类型uint。有符号的整数类型会使用最高位的比特（bit）表示整数的正负。显然，这会对它能表示的整数的范围有一定的损耗（使其缩小）。而无符号的整数类型会使用所有的比特位来表示数值。如此类型的值均为正数。这也是用“无符号的”来形容它们的原因。在不同的计算架构的计算机之上，它们体现的宽度是不同的。宽度即指存储一个某类型的值所需要的空间。空间的单位可以是比特，也可以是字节（byte）。请看下表。

除了这两个计算架构相关的整数类型之外，还有8个可以显式表达自身宽度的整数类型。如下表所示。

2. 浮点数

　　浮点数类型有两个，即float32和float64。你可能已经想到，存储这两个类型的值的空间分别需要4个字节和8个字节。浮点数类型的值一般由整数部分、小数点“.”和小数部分组成。其中，整数部分和小数部分均由10进制表示法表示。不过还有另一种表示方法。那就是在其中加入指数部分。指数部分由“E”或“e”以及一个带正负号的10进制数组成。比如，3.7E-2表示浮点数0.037。又比如，3.7E+1表示浮点数37。有时候，浮点数类型值的表示也可以被简化。比如，37.0可以被简化为37。又比如，0.037可以被简化为.037。
有一点需要注意，在Go语言里，浮点数的相关部分只能由10进制表示法表示，而不能由8进制表示法或16进制表示法表示。比如，03.7表示的一定是浮点数3.7。

3. 复数类型

　　复数类型同样有两个，即complex64和complex128。存储这两个类型的值的空间分别需要8个字节和16个字节。实际上，complex64类型的值会由两个float32类型的值分别表示复数的实数部分和虚数部分。而complex128类型的值会由两个float64类型的值分别表示复数的实数部分和虚数部分。
　　复数类型的值一般由浮点数表示的实数部分、加号“+”、浮点数表示的虚数部分，以及小写字母“i”组成。比如，3.7E+1 + 5.98E-2i。正因为复数类型的值由两个浮点数类型值组成，所以其表示法的规则自然需遵从浮点数类型的值表示法的相关规则。

4. byte与rune

　　byte与rune类型有一个共性，即：它们都属于别名类型。byte是uint8的别名类型，而rune则是int32的别名类型。byte类型的值需用8个比特位表示，其表示法与uint8类型无异。因此我们就不再这里赘述了。我们下面重点说说rune类型。
　　+一个rune类型的值即可表示一个Unicode字符。Unicode是一个可以表示世界范围内的绝大部分字符的编码规范。关于它的详细信息，可以参看其官网（http://unicode.org/）上的文档，或在Google上搜索。用于代表Unicode字符的编码值也被称为Unicode代码点。一个Unicode代码点通常由“U+”和一个以十六进制表示法表示的整数表示。例如，英文字母“A”的Unicode代码点为“U+0041”。rune类型的值需要由单引号“’”包裹。

补充：Go 八进制、十六进制，以及科学计数法。标准库 math 定义了各种数字类型的取值范围。

a, b, c, d := 071, 0x1F, 1e9, math.MinInt16
输出结果：
a: 57
b: 31
c: 1e+09
d: -32768

Go 空指针的值为nil 在C/C++ 是 NULL

四、引用类型

　　引用类型包括 slice、map、channel。他们又复杂的内部结构，除了申请内存外还要初始化相关属性。
　内置函数 new 计算类型大小，为其分配零值内存，返回指针。而 make 会被编译器翻译成具体的创建函数，由其分配内存和初始化成员结构，返回对象而非指针。

a := []int{0, 0, 0} // 提供初始化表达式。
a[1] = 10
b := make([]int, 3) // makeslice
b[1] = 10
c := new([]int)
c[1] = 10           // Error: invalid operation: c[1] (index of type *[]int)

五、类型转换

• 不支持隐式类型转换，即便是从窄向宽转换也不行。

var b byte = 100
// var n int = b // Error: cannot use b (type byte) as type int in assignment
var n int = int(b) // 显式转换

• 使用括号避免优先级错误。

*Point(p) // 相当于 *(Point(p))
(*Point)(p)
<-chan int(c) // 相当于 <-(chan int(c))
(<-chan int)(c)

• 同样不能其他类型当bool 值使用。

a := 100
if a { // Error: non-bool a (type int) used as if condition
println("true")
}

六、字符串

字符串是不可变值类型，内部⽤用指针指向 UTF-8 字节数组。

• 默认值是空字符串 “”。
• 用索引号访问某字节，如 s[i]。
• 不能用序号获取字节元素指针，&s[i] 非法。
• 不可变类型，无法修改字节数组。

runtime.h
struct String
{
    byte* str;
    intgo len;
};

• 使用索引号访问字符（byte）。

s := "abc"
println(s[0] == '\x61', s[1] == 'b', s[2] == 0x63)

输出结果：

true true true

• 使用“`”定义不做转义处理的原是字符串，支持跨行。

s := `a
b\r\n\x00
c`
println(s)

输出：

a
b\r\n\x00
c

• 连接跨行字符串时，“+”必须在上一行的行末，否则导致编译错误。

s := "Hello, " +
"World!"
s2 := "Hello, "
+ "World!" // Error: invalid operation: + untyped string

• 支持用两个索引号返回子串。子串依然指向原字节数组，仅修改了指针和长度属性。

s := "Hello, World!"
s1 := s[:5] // Hello
s2 := s[7:] // World!
s3 := s[1:5] // ello

• 单引号字符常量表示 Unicode Code Point，支持\uFFFF、\U7FFFFFFF、\xFF格式。对应rune类型，UCS-4。rune是int32的别名。

func main() {
    fmt.Printf("%T\n", 'a')
    var c1, c2 rune = '\u6211', '们'
    println(c1 == '我', string(c2) == "\xe4\xbb\xac")
}

输出结果：

int32
true true

• 要修改字符串可以先将其转换成[]rune或[]byte，完成后再转换为string。无论哪种转换，都会重新分配内存，并复制字节数组。

func main() {
    s := "abcd"
    bs := []byte(s)
    bs[1] = 'B'
    println(string(bs))
    u := "电脑"
    us := []rune(u)
    us[1] = '话'
    fmt.Println(string(us))
}

输出结果：

aBcd
电话

• 用for循环遍历字符串时，也有byte和rune两种方式。

func main() {
    s := "abc汉字"
    for i := 0; i < len(s); i++ { // byte
        fmt.Printf("%c,", s[i])
    }
    fmt.Println()
    for _, r := range s { // rune
        fmt.Printf("%c,", r)
    }
}

输出结果： 注 这是在32位机器下编译运行的结果

a,b,c,æ,±,‰,å,­,—,
a,b,c,汉,字,

七、指针

　　支持指针类型 T，指针的指针 **T,以及包含包前缀的 < package>.T。

• 默认值nil，没有NULL常量。
• 操作符“&”取变量地址，“*”通过指针访问目标对象。
• 不支持指针运算，不支持“->”运算，直接用“.”访问目成员。

func main() {
    type data struct{ a int }
    var d = data{1234}
    var p *data
    p = &d
    fmt.Printf("%p, %v\n", p, p.a) // 直接用指针访问目标对象成员，无须转换。
}

输出结果：

0x115b00cc, 1234

• 不能对指针做加减法等运算。

x := 1234
p := &x
p++   /// Error: invalid operation: p += 1 (mismatched types *int and int)

• 可以在unsafe.Pointer和任意类型指针间进行转换。注意引入unsafe包

func main() {
    x := 0x12345678
    p := unsafe.Pointer(&x) // *int -> Pointer
    n := (*[4]byte)(p) // Pointer -> *[4]byte
    for i := 0; i < len(n); i++ {
        fmt.Printf("%X ", n[i])
    }
}

输出结果：

78 56 34 12

• 返回局部变量指针是安全的，编译器会根据需要将其分配在GC Heap上。

func test() *int {
x := 100
return &x // 在堆上分配 x 内存。但在内联时，也可能直接分配在目标栈。
}

• 将Pointer转换成uintptr，可变相实现指针运算。

func main() {
    d := struct {
        s string
        x int
    }{"abc", 100}
    p := uintptr(unsafe.Pointer(&d)) // *struct -> Pointer -> uintptr
    p += unsafe.Offsetof(d.x) // uintptr + offset
    p2 := unsafe.Pointer(p) // uintptr -> Pointer
    px := (*int)(p2) // Pointer -> *int
    *px = 200 // d.x = 200
    fmt.Printf("%#v\n", d)
}

输出结果：

struct { s string; x int }{s:"abc", x:200}

注意：GC将uintptr当成普通整数对象，它无法阻止“关联”对象被回收。

八、自定义类型

　　可将类型分为命名和未命名两大类。命名类型包括bool、int、string等，而array、slice、map等和具体元素类型、长度有关，属于未命名类型。
　　具有相同声明的未命名类型被视为同一类型。

• 具有相同基类型的指针。
• 具有相同元素类型和长度的array。
• 具有相同元素类型的slice。
• 具有相同键值类型的map。
• 具有相同元素类型和传送方向的channel。
• 具有相同字段序列（字段名、类型、标签、顺序）的匿名struct。
• 签名相同（参数和返回值，不包括参数名称）的function。
• 方法集相同（方法名、方法签名相同，和次序无关）的interface。

var a struct { x int `a` }
var b struct { x int `ab` }
// cannot use a (type struct { x int "a" }) as type struct { x int "ab" } in assignment
b = a

• 可用type在全局或函数内定义新类型。

func main() {
    type bigint int64
    var x bigint = 100
    println(x)
}

• 新类型不是原类型的别名，除了拥有相同的数据存储结构外，它们之间没有任何关系，不会持有原类型任何信息。除非目标类型是未命名类型，否则必须显式转换。

x := 1234
var b bigint = bigint(x) // 必须显式转换，除非是常量。
var b2 int64 = int64(b)
var s myslice = []int{1, 2, 3} // 未命名类型，隐式转换。
var s2 []int = s

九、总结

　　本部分，简要介绍了Go 语言的数据类型。注意它们与我们C语言数据类型的差异，能够更好的理解和掌握它们。

参考资料

1. Go 语言第一课
2. Go 学习笔记(雨痕)
3. Go 官网教程 Tour