第05章 - 复合数据类型

本章讲解 Go 的四种核心复合数据类型：数组、切片、映射（map）和结构体。它们是组织和存储数据的基础，其中切片和 map 是日常开发中使用频率最高的类型。

5.1 数组

数组是固定长度、相同类型元素的序列。长度是数组类型的一部分，[3]int 和 [5]int 是不同的类型。

var a [3]int          // 声明长度为 3 的整型数组，元素初始化为零值
a[0] = 10
fmt.Println(a)        // [10 0 0]

// 字面量初始化
b := [3]int{1, 2, 3}

// 让编译器推断长度
c := [...]int{1, 2, 3, 4} // 长度为 4

// 指定索引初始化
d := [5]int{0: 10, 4: 50}  // [10 0 0 0 50]

5.1.1 数组是值类型

数组是值类型，赋值或作为参数传递时会完整复制。修改副本不会影响原数组：

a := [3]int{1, 2, 3}
b := a       // 完整复制
b[0] = 100
fmt.Println(a) // [1 2 3]，未改变

正因为这种复制开销，实际开发中很少直接使用数组，而是使用更灵活的切片。

5.2 切片

切片（slice）是对底层数组的一段连续片段的引用，是 Go 中最重要、最常用的数据结构。它由三部分组成：指向底层数组的指针、长度（len）、容量（cap）。

5.2.1 创建切片

// 字面量
s := []int{1, 2, 3}

// make 创建：make([]T, 长度, 容量)
s := make([]int, 5)      // 长度 5，容量 5，元素全为 0
s := make([]int, 3, 10)  // 长度 3，容量 10

// 从数组或切片切取：s[low:high]，左闭右开
arr := [5]int{1, 2, 3, 4, 5}
s := arr[1:4]            // [2 3 4]

5.2.2 长度与容量

• 长度（len）：切片当前包含的元素个数。
• 容量（cap）：从切片起始位置到底层数组末尾的元素个数。

s := make([]int, 3, 10)
fmt.Println(len(s), cap(s)) // 3 10

5.2.3 append 追加元素

append 向切片末尾追加元素。当容量不足时，Go 会自动分配一个更大的底层数组（通常翻倍扩容），并将原数据复制过去：

s := []int{1, 2, 3}
s = append(s, 4)          // [1 2 3 4]
s = append(s, 5, 6, 7)    // 追加多个
s = append(s, other...)   // 追加另一个切片

重要：append 可能返回一个指向新底层数组的切片，因此必须用返回值覆盖原变量：s = append(s, ...)。

5.2.4 切片共享底层数组的陷阱

多个切片可能共享同一个底层数组，修改一个会影响另一个：

a := []int{1, 2, 3, 4, 5}
b := a[1:3]   // [2 3]，与 a 共享底层数组
b[0] = 100
fmt.Println(a) // [1 100 3 4 5]，a 也被改变！

如需独立副本，应使用 copy：

src := []int{1, 2, 3}
dst := make([]int, len(src))
copy(dst, src) // 深拷贝元素

5.2.5 删除元素

Go 没有内置的删除函数，需借助 append 实现：

// 删除索引 i 处的元素
s = append(s[:i], s[i+1:]...)

5.2.6 nil 切片与空切片

var s []int          // nil 切片，len=0, cap=0, s == nil 为 true
s := []int{}         // 空切片，len=0, cap=0, 但 s != nil

两者都可以安全地 append，通常推荐使用 var s []int 声明 nil 切片。

5.3 映射 map

map 是键值对的无序集合，类似其他语言的哈希表、字典。键必须是可比较的类型（如字符串、数字、布尔、指针、结构体等，但不能是切片、map、函数）。

5.3.1 创建与基本操作

// make 创建
m := make(map[string]int)
m["apple"] = 5
m["banana"] = 3

// 字面量创建
scores := map[string]int{
    "Alice": 90,
    "Bob":   85,
}

// 读取
v := m["apple"]      // 5
v = m["unknown"]     // 0（键不存在返回值类型的零值）

// 删除
delete(m, "apple")

// 长度
fmt.Println(len(m))

5.3.2 判断键是否存在

通过"逗号 ok"惯用法区分"键不存在"和"值为零值"：

value, ok := m["apple"]
if ok {
    fmt.Println("存在:", value)
} else {
    fmt.Println("不存在")
}

5.3.3 遍历 map

for key, value := range m {
    fmt.Printf("%s = %d\n", key, value)
}

注意：map 的遍历顺序是随机的，每次运行可能不同。如需有序遍历，应将键提取到切片后排序。

5.3.4 map 的注意事项

• map 是引用类型，传递时不复制底层数据。
• 对 nil map 写入会 panic，必须先用 make 初始化。
• map 不是并发安全的，多 goroutine 并发读写需加锁或使用 sync.Map（详见第 9 章）。

5.4 结构体

结构体（struct）是将多个不同类型的字段组合在一起的复合类型，是 Go 实现面向对象编程的基础。

5.4.1 定义与初始化

type Person struct {
    Name string
    Age  int
    Email string
}

// 按字段名初始化（推荐，可读性强且字段顺序无关）
p1 := Person{Name: "Alice", Age: 30, Email: "alice@example.com"}

// 按顺序初始化（必须提供所有字段）
p2 := Person{"Bob", 25, "bob@example.com"}

// 先声明后赋值
var p3 Person
p3.Name = "Carol"

5.4.2 访问与修改字段

通过 . 操作符访问字段：

fmt.Println(p1.Name)
p1.Age = 31

5.4.3 结构体是值类型

与数组一样，结构体是值类型，赋值和传参时会完整复制。若要在函数中修改结构体或避免复制开销，应使用指针：

func birthday(p *Person) {
    p.Age++ // 通过指针修改原结构体（Go 自动解引用）
}

birthday(&p1)

5.4.4 匿名结构体

适用于临时数据组织，无需预先定义类型：

config := struct {
    Host string
    Port int
}{
    Host: "localhost",
    Port: 8080,
}

5.4.5 嵌套与匿名字段（组合）

Go 不支持继承，而是通过组合实现代码复用。嵌入匿名字段后，可直接访问内嵌结构体的字段和方法：

type Animal struct {
    Name string
}

type Dog struct {
    Animal // 匿名嵌入
    Breed  string
}

d := Dog{Animal: Animal{Name: "旺财"}, Breed: "柴犬"}
fmt.Println(d.Name)  // 直接访问内嵌字段，等价于 d.Animal.Name

5.4.6 结构体标签

字段后可附加标签（tag），常用于序列化场景指定字段映射规则，反射机制会读取这些标签（详见第 13 章）：

type User struct {
    Name  string `json:"name"`
    Email string `json:"email,omitempty"`
    Age   int    `json:"age"`
}

序列化为 JSON 时，字段名将使用标签中指定的小写形式。

5.5 本章小结

本章介绍了 Go 的四种复合数据类型。数组是定长值类型，实际中较少直接使用；切片是动态、灵活的引用类型，是最常用的序列结构，但需注意其共享底层数组的特性；map 提供高效的键值存储；结构体通过组合方式组织数据，是面向对象的基础。深入理解切片的底层机制（len/cap/扩容）和值/引用语义，是写出正确高效 Go 代码的关键。

下一章我们将学习方法与接口，深入 Go 的面向对象编程。