4.1 Array
数组是值类型，赋值和传参会复制整个数组，而不是指针
数组长度必须是常量，且是类型的组成部分，[2]int 和 [3]int 是不同类型
支持 “==”、"!=" 操作符，因为内存总是被初始化过的
指针数组 [n]*T，数组指针 *[n]T
a := [3]int{1, 2} // 未初始化元素值为 0。
b := [...]int{1, 2, 3, 4} // 通过初始化值确定数组⻓度。
c := [5]int{2: 100, 4: 200} // 使⽤索引号初始化元素。
d := [...]struct {
name string
age uint8
}{
{"user1", 10}, // 可省略元素类型。
{"user2", 20}, // 别忘了最后⼀⾏的逗号。
}
支持多维数组
a := [2][3]int{{1, 2, 3}, {4, 5, 6}}
b := [...][2]int{{1, 1}, {2, 2}, {3, 3}} // 第 2 纬度不能⽤ "..."。
值拷贝行为会造成性能问题，通常会建议使用slice，或数组指针
func test(x [2]int) {
fmt.Printf("x: %pn", &x)
x[1] = 1000
fmt.Printf("x=%v n", x)
}
func main() {
a := [2]int{}
fmt.Printf("a: %pn", &a)
test(a)
fmt.Printf("a=%v n", a)
}
内置函数 len 和 cap 都返回数组⻓度 (元素数量)
a := [2]int{}
println(len(a), cap(a)) // 2, 2
4.2 Slice
slice 并不是数组或数组指针。它通过内部指针和相关属性引用数组片段，以
实现变长方案
struct Slice
{
byte* array; // actual data
uintgo len; // number of elements
uintgo cap; // allocated number of elements
}
引用类型。但自身是结构体，值拷贝传递
属性 len 表示可用元素数量，读写操作不能超过该限制
属性 cap 表示最大扩张容量，不能超出数组限制
如果 slice == nil，那么 len、cap 结果都等于 0
data := [...]int{0, 1, 2, 3, 4, 5, 6}
slice := data[1:4:5] // [low : high : max]
创建表达式使用的是元素索引号，而非数量
读写操作实际目标是底层数组，只需注意索引号的差别
data := [...]int{0, 1, 2, 3, 4, 5}
s := data[2:4]
s[0] += 100
s[1] += 200
fmt.Println(s)
fmt.Println(data)
可直接创建 slice 对象，自动分配底层数组
s1 := []int{0, 1, 2, 3, 8: 100} // 通过初始化表达式构造，可使⽤索引号
fmt.Println(s1, len(s1), cap(s1))
s2 := make([]int, 6, 8) // 使⽤ make 创建，指定 len 和 cap 值
fmt.Println(s2, len(s2), cap(s2))
s3 := make([]int, 6) // 省略 cap，相当于 cap = len
fmt.Println(s3, len(s3), cap(s3))
使用 make 动态创建 slice，避免了数组必须用常量做长度的麻烦。还可用指针直接访问底层数组，退化成普通数组操作
s := []int{0, 1, 2, 3}
p := &s[2] // *int, 获取底层数组元素指针。
*p += 100
fmt.Println(s)
至于[ ][ ]T，是指元素类型为 [ ]T
data := [][]int{
[]int{1, 2, 3},
[]int{100, 200},
[]int{11, 22, 33, 44},
}
可直接修改 struct array/slice 成员
// 列表
d := [5]struct {
x int
}{}
// 切片
s := d[:]
d[1].x = 10
s[2].x = 20
fmt.Printf("d=%vn", d)
fmt.Printf("&d=%p, &d[0]=%p, &d[1]=%p,&d[2]=%p,&d[3]=%p,&d[4]=%pn", &d, &d[0], &d[1], &d[2], &d[3], &d[4])
fmt.Printf("s=%vn", s)
fmt.Printf("&s=%p, &s[0]=%p,&s[1]=%p,&s[2]=%p,&s[3]=%p,&s[4]=%pn", &s, &s[0], &s[1], &s[2], &s[3], &s[4])
reslice，是基于已有 slice 创建新 slice 对象，以便在 cap 允许范围内调整属性
s := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
s1 := s[2:5] // [2 3 4]
s2 := s1[2:6:7] // [4 5 6 7], 7为最大索引值
s3 := s2[3:6] // Error，右索引值6超出索引边界
s := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
s1 := s[2:5] // [2 3 4]
s1[2] = 100
s2 := s1[2:6] // [100 5 6 7]
s2[3] = 200
fmt.Println(s)
append，向 slice 尾部添加数据，返回新的 slice 对象
s := make([]int, 0, 5)
fmt.Printf("s=%v, &s=%pn", s, &s)
s2 := append(s, 1)
fmt.Printf("s2=%v, &s2=%pn", s2, &s2)
就是在 array[slice.high] 写数据
data := [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
s := data[:3]
s2 := append(s, 100, 200) // 添加多个值。
fmt.Printf("data=%v, &data[0]=%p, &data=%pn", data, &data[0], &data)
fmt.Printf("s=%v, &s[0]=%p, &s=%pn", s, &s[0], &s)
fmt.Printf("s2=%v, &s2[0]=%p, &s2=%pn", s2, &s2[0], &s2)
⼀旦超出原 slice.cap 限制，就会重新分配底层数组，即便原数组并未填满
从输出结果可以看出，append 后的 s 重新分配了底层数组，并复制数据。如果只追加一个值，则不会超过 s.cap 限制，也就不会重新分配
data := [...]int{0, 1, 2, 3, 4, 10: 0}
s := data[:2:3]
s = append(s, 100, 200) // ⼀次 append 两个值，超出 s.cap 限制。
fmt.Printf("s=%v, data=%vn", s, data)
fmt.Printf("&s=%p, &s[0]=%pn", &s, &s[0]) // 重新分配底层数组，与原数组⽆关。
fmt.Printf("&data=%p, &data[0]=%pn", &data, &data[0]) // ⽐对底层数组起始指针。
通常以 2 倍容量重新分配底层数组。在大批量添加数据时，建议一次性分配足够大的空间，以减少内存分配和数据复制开销。或初始化足够长的 len 属性，改用索引号进行操作。及时释放不再使用的 slice 对象，避免持有过期数组，造成 GC 无法回收
注意：
当原切片长度小于1024时，新切片的容量会直接翻倍。而当原切片的容量大于等于1024时，会反复地增加25%，直到新容量超过所需要的容量
s := make([]int, 0, 1)
c := cap(s)
for i := 0; i < 50; i++ {
s = append(s, i)
if n := cap(s); n > c {
fmt.Printf("cap: %d -> %dn", c, n)
c = n
}
}
函数 copy 在两个 slice 间复制数据，复制长度以 len 小的为准。两个 slice 可指向同一底层数组，允许元素区间重叠
注意：
考虑到复制函数的特性， 应及时将所需数据 copy 到较小的 slice，以便释放超大号底层数组内存
data := [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
s := data[8:]
s2 := data[:5]
fmt.Printf("s2=%v, s=%vn", s2, s)
copy(s2, s) // dst:s2, src:s
fmt.Printf("s2=%v, data=%v", s2, data)
Map,引用类型，哈希表，键必须是支持相等运算符 (==、!=) 类型，比如 number、string、pointer、array、struct，以及对应的 interface。值可以是任意类型，没有限制
m := map[int]struct {
name string
age int
}{
1: {"user1", 10}, // 可省略元素类型。
2: {"user2", 20},
}
println(m[1].name)
预先给 make 函数一个合理元素数量参数，有助于提升性能。因为事先申请一大块内存，可避免后续操作时频繁扩张
m := make(map[string]int, 1000)
map的常见操作
注意：
map的循环是不能保证迭代返回次序，通常是随机结果，具体和版本实现有关
// 初始化map变量
m := map[string]int{
"a": 1,
}
// 判断map中是否有想要的key
if v, ok := m["a"]; ok { // 判断 key 是否存在。
fmt.Printf("map中的key=%v是否存在：%vn", v, ok)
}
fmt.Printf("打印m[c]的值：%vn", m["c"]) // 对于不存在的 key，直接返回 ，不会出错。
m["b"] = 2 // 新增或修改。
delete(m, "c") // 删除。如果 key 不存在，不会出错。
fmt.Printf("map的长度为：%vn", len(m)) // 获取键值对数量。cap ⽆效。
for k, v := range m { // 迭代，可仅返回 key。随机顺序返回，每次都不相同。
fmt.Printf("map的key为：%v,map的value为：%vn", k, v)
}
从 map 中取回的是⼀个 value 临时复制品，对其成员的修改是没有任何意义的
正确做法是完整替换 value
type user struct{ name string }
m := map[int]user{ // 当 map 因扩张⽽重新哈希时，各键值项存储位置都会发⽣改变。 因此，map
1: {"user1"}, // 被设计成 not addressable，类似 m[1].name 这种期望透过原 value
} // 指针修改成员的⾏为⾃然会被禁⽌。
// m[1].name = "Tom" // Error: cannot assign to m[1].name
u := m[1]
u.name = "Tom"
m[1] = u // 替换 value
或使用指针
type user struct{ name string }
m2 := map[int]*user{
1: &user{"user1"},
}
m2[1].name = "Jack" // 返回的是指针复制品，透过指针修改原对象是允许的
fmt.Printf("m2=%v, *m2[1]=%v", m2, *m2[1])
可以在迭代时安全删除键值。但如果期间有新增操作，那么就不知道会有什么意外了
for i := 0; i < 5; i++ {
m := map[int]string{
0: "a", 1: "a", 2: "a", 3: "a", 4: "a",
5: "a", 6: "a", 7: "a", 8: "a", 9: "a",
}
for k := range m {
fmt.Printf("k=%vn", k)
m[k+k] = "x"
fmt.Printf("m[%v]=%vn", k+k, m[k+k])
fmt.Printf("delete before m=%vn", m)
delete(m, k)
fmt.Printf("delete m[%v] after m=%vn", k, m)
}
fmt.Printf("循环第%v次的最终m=%vnn", i, m)
}
//由于在循环遍历的时候map里的循环顺序并不是按照key值有序排列的，而是map每次循环的顺序都不一样，因此在同时删除和添加的时候会造成结果的不确定性
Struct， 值类型，赋值和传参会复制全部内容。可用"_" 定义补位字段，支持指向自身类型的指针成员
type Node struct {
_ int
id int
data *byte
next *Node
}
func main() {
n1 := Node{
id: 1,
data: nil,
}
n2 := Node{
id: 2,
data: nil,
next: &n1,
}
fmt.Printf("n2=%vn *(n2.next)=%vn", n2, *(n2.next))
}
顺序初始化必须包含全部字段，否则会出错
type User struct {
name string
age int
}
u1 := User{"Tom", 20}
u2 := User{"Tom"} // Error: too few values in struct initializer
支持匿名结构，可用作结构成员或定义变量
type File struct {
name string
size int
attr struct {
perm int
owner int
}
}
func main() {
f := File{
name: "test.txt",
size: 1025,
// attr: {0755, 1}, // Error: missing type in composite literal
}
// 方法1
f.attr.perm = 10
f.attr.owner = 1
// 方法2
// var attr = struct {
// perm int
// owner int
// }{2, 0755}
// f.attr = attr
fmt.Printf("f=%v", f)
}
由于结构体是值类型，所以支持 “==”、"!=" 相等操作符，可用作 map 键类型
type User struct {
id int
name string
}
m := map[User]int{
User{1, "Tom"}: 100,
}
fmt.Printf("m=%v", m)
可定义字段标签，⽤反射读取。标签是类型的组成部分
var u1 struct { name string "username" }
var u2 struct { name string }
u2 = u1 // Error: cannot use u1 (type struct { name string "username" }) as
// type struct { name string } in assignment
空结构 “节省” 内存，比如用来实现 set 数据结构，或者实现没有 “状态” 只有方法的 “静态类”
var null struct{}
set := make(map[string]struct{})
set["a"] = null
匿名字段，它不过是一种语法糖，从根本上说，就是一个与成员类型同名 (不含包名) 的字段。被匿名嵌入的可以是任何类型，当然也包括指针
type User struct {
name string
}
type Manager struct {
User
title string
}
m := Manager{
User: User{"Tom"}, // 匿名字段的显式字段名，和类型名相同。
title: "Administrator",
}
fmt.Printf("m=%v", m)
可以像普通字段那样访问匿名字段成员，编译器从外向内逐级查找所有层次的匿名字段，直到发现目标或出错
type Resource struct {
id int
}
type User struct {
Resource
name string
}
type Manager struct {
User
title string
}
var m Manager
m.id = 1
m.name = "Jack"
m.title = "Administrator"
外层同名字段会遮蔽嵌入字段成员，相同层次的同名字段也会让编译器无所适从。解决方法是使用显式字段名
type Resource struct {
id int
name string
}
type Classify struct {
id int
}
type User struct {
Resource // Resource.id 与 Classify.id 处于同⼀层次。
Classify
name string // 遮蔽 Resource.name。
}
u := User{
Resource{1, "people"},
Classify{100},
"Jack",
}
fmt.Println(u.name) // User.name: Jack
fmt.Println(u.Resource.name) // people
// println(u.id) // Error: ambiguous selector u.id
fmt.Println(u.Classify.id) // 100
不能同时嵌入某一类型和其指针类型，因为它们名字相同
type Resource struct {
id int
}
type User struct {
*Resource
// Resource // Error: duplicate field Resource
name string
}
u := User{
&Resource{1},
"Administrator",
}
fmt.Println(u.id)
fmt.Println(u.Resource.id)
面向对象，面向对象三大特征里，Go 仅支持封装，尽管匿名字段的内存布局和行为类似继承。没有class 关键字，没有继承、多态等等
type User struct {
id int
name string
}
type Manager struct {
User
title string
}
m := Manager{User{1, "Tom"}, "Administrator"}
// var u User = m // Error: cannot use m (type Manager) as type User in assignment
// 没有继承，⾃然也不会有多态。
var u User = m.User // 同类型拷⻉。
fmt.Printf("u=%v", u)
内存布局和 C struct 相同，没有任何附加的 object 信息
可用 unsafe 包相关函数输出内存地址信息
