Array
和其他语言的数组不同。
- 数组是值类型，赋值和传参会复制整个数组，而不是指针。
- 数组长度必须是常量，且是类型的组成部分。
2[int]和3[int]是不同类型。 - 支持
==、!=操作符，因为内存总是被初始化过。 - 指针数组
[n]*T、数组指针*[n]T
初始化
a := [3]int{1, 2} // 未初始化元素值为 0
b := [...]int{1, 2, 3, 4} // 通过初始化确定数组长度
值拷贝会造成性能问题，通常会使用 slice，或数组指针。
len、cap
返回数组的长度与容量。
a := [2]int{}
println(len(a), cap(a)) // 2, 2
Slice
既然数组是值类型无法方便地传递给函数，肯定提供了方便的指针类型。
slice 并不是数组或数组指针，内部通过指针和相关属性引用数组片段，以实现变长方案。
slice 本质上是一个指向底层数组的结构体。
struct Slice
{
byte* array; // actual data
uintgo len; // number of elements
uintgo cap; // allocated number of elements
}
- 引用类型。但自身是结构体，值拷贝传递。
- 每部分只有
8个字节，长度永远不会超过24字节，在使用时不需要传递silce的地址，直接使用值传递。 - 属性
len表示可用元素数量，读写操作不能超过该限制。 - 属性
cap表⽰最⼤扩张容量，不能超出数组限制。 - 如果
slice == nil，那么len、cap结果都等于0。
data := [...]int{0, 1, 2, 3, 4, 5, 6}
// len = high - low
// cap = max - low
slice := data[1:4:5] // [low : high : max]
slice 读写操作实际目标是底层数组，需要注意索引号的区别。
创建
直接创建 slice 对象，自动分配底层数组。
// 索引位置 8 的值为 100
s1 := []int{0, 1, 2, 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))
输出
[0 1 2 3 0 0 0 0 100] 9 9
[0 0 0 0 0 0] 6 8
[0 0 0 0 0 0] 6 6
使用 make 动态创建 slice，避免数组必须用常量做长度的麻烦。还可以用指针直接访问底层数组，变成普通数组操作。
s := []int{0, 1, 2, 3}
p := &s[2] // *int 获取底层数组元素指针
fmt.Println(s) // [0 1 102 3]
[][]T，是指元素类型为 []T。
reslice
基于现有 slice 对象创建新 slcie 对象，以便在 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]
s3 := s2[3:6] // Error
append
append 向 slice 尾部添加数据，返回新的 slice 对象。简单说就是在 array[slice.high] 后面写数据，会修改底层数组的值。
data := [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
s := data[:3]
s2 := append(s, 100, 200) // 添加多个值。
s3 := append(s2, s...) // ... 解构赋值，相当于把 silce 展开
fmt.Println(data)
fmt.Println(s)
fmt.Println(s2)
fmt.Println(s3)
输出
[0 1 2 100 200 0 1 2 8 9]
[0 1 2]
[0 1 2 100 200]
[0 1 2 100 200 0 1 2]
追加后的容量一旦超过 slice.cap 的限制，会重新分配底层数组，即便原数组并未填满。
通常以 2 倍容量重新分配底层数组。在⼤批量添加数据时，建议⼀次性分配⾜够⼤的空间，以减少内存分配和数据复制开销。或初始化⾜够⻓的 len 属性，改⽤索引号进⾏操作。及时释放不再使⽤的 slice 对象，避免持有过期数组，造成 GC ⽆法回收。
remove
官方并没有 remove 的相关接口，可以使用 append 变相实现该接口。
// 删除第五个元素
index := 5
s := append(s[:index], s[index + 1:]...)
insert
官方也没有往指定位置插入元素的接口，依旧可以使用 append 实现。
temp := append([]string{}, s[index:]...)
s = append(s[:index], "insert")
s = append(s, temp...)
copy
函数 copy 在两个 slice 之间复制数据，复制长度以 len 小的为准，复制较小的个数。两个 slice 允许指向同一底层数组，允许元素区间重叠。
copy(to, from)
data := [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
s := data[8:] // [8, 9]
s2 := data[:5] // [0, 1, 2, 3, 4]
copy(s2, s) // 从 s 复制到 s2
fmt.Println(s2) // [8, 9, 2, 3, 4]
fmt.Println(data) // 底层数组被改变 [8, 9, 2, 3, 4, 5, 6, 7, 8, 9]
应及时将所需数据 copy 到较⼩的 slice，以便释放超⼤号底层数组内存。
Map
引用类型，Hash 表在任何语言中都有，C++ 中是 std::map<>， Java 中是 Hashamp<>，在 Go 中则内置 map 不需要引入任何库。
map 的键必须支持比较运算 == 和 !=，可以是 string、number、pointer、array、struct 等。值可以是任意类型，没有限制，取值的时候如果不存在就返回零值。
map 本质上是一个字典指针
type Map_K_V struct {
// ...
}
type map[K]V struct {
impl *Map_k_V
}
预先给 make 函数⼀个合理元素数量参数，有助于提升性能。因为事先申请⼀⼤块内存，可避免后续操作时频繁扩张。
m := make(map[string]int, 1000)
常见操作
m := map[string]int{
"a": 1,
}
// 判断 key 是否存在
if v, ok := m["a"]; ok {
println(v)
}
// 不存在的 key 返回零值
m["b"] // 0
// 新增或修改
m["b"] = 2
// 删除，如果 key 不存在不会出错
delete(map, key)
// 获取键值对数量
println(len(m))
// 迭代，随机顺序返回
// range 返回 value 的临时拷贝
for k, v := range m {
println(k, v)
}
从 map 中取回的是一个 value 临时复制品，对其成员修改不会改变源对象。
正确的做法是完整对象替换或使用指针作为 value。
Struct
值语义，赋值和传参会复制全部内容。可⽤ "_" 定义补位字段，支持指向自身类型的指针成员。
支持 ==、!= 操作符。
type Node struct {
_ int
id int
data *byte
next *Node
}
type User struct {
id int
name string
}
user1 := User{1, "Tom"}
user2 := User{1, "Tom"}
fmt.Println(user1 == user2) // true
空结构 "节省" 内存，⽐如⽤来实现 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",
}
m.name = "jack" // 访问匿名字段成员
可以像访问普通字段一样访问匿名字段成员，编译器从外向内逐级查找所有层次的匿名字段，直到发现目标或出错。
外层同名字段会遮蔽嵌⼊字段成员，相同层次的同名字段也会让编译器⽆所适从。解决⽅法是使⽤显式字段名。
本质上就是不能有歧义，不能同时找到两个，而不知道使用哪一个。
面向对象
面向对象三大特征里，Go 仅支持封装，尽管匿名字段的内存布局和行为类似继承。没有 class 关键字，没有继承、多态等等。
内存布局和 C struct 相同，没有任何附加的 object 信息。
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 // 同类型拷贝
内存布局
|<-------- User:24 ------->|<-- title:16 -->|
+-------------+------------+----------------+ +---------------+
m | 1 | string | string | | Administrator | [n]byte
+-------------+------------+----------------+ +---------------+
| | |
| +--->>>------------->>>--------+
|
+--->>>----------------------------------------+
|
+--->>>-------------------------------------+ |
| | |
+-------------+------------+ +-------------+
u | 1 | string | | Tom | [n]byte
+-------------+------------+ +-------------+ |<- id:8 ->|<- name:16->|
