本章深入解析Go语言中常用的复合数据类型，包含底层实现原理、操作方法和性能注意事项。

3.1 数组与切片

3.1.1 数组 (Array)

• 定义与特性

// 声明长度为3的整型数组（长度是类型的一部分）
var arr1 [3]int           // 默认初始化为[0,0,0]
arr2 := [3]int{1, 2}      // 显式初始化，第三个元素为0 → [1,2,0]
arr3 := [...]int{1,2,3}   // 编译器推断长度 → [1,2,3]

• 内存连续分配，访问时间复杂度O(1)
• 长度不可变，类型包含长度信息（[3]int与[5]int是不同的类型）

3.1.2 切片 (Slice)

• 底层结构（指针+长度+容量）

// 创建方式
s1 := make([]int, 3, 5)    // 类型[]int，长度3，容量5
s2 := arr2[1:3]            // 基于数组创建（左闭右开区间）
s3 := []int{1, 2, 3}       // 直接初始化

• 扩容机制

• 当len > cap时触发扩容，新容量通常为原容量的2倍（小于1024时）
• 扩容后底层数组改变，原有切片仍指向旧数组

3.1.3 常用操作

最佳实践

• 预先分配容量（make([]T, 0, capacity)）避免频繁扩容
• 大切片优先传递指针（func f(s *[]int)）减少内存复制

3.2 映射 (Map)

3.2.1 基本使用

// 声明与初始化
var m1 map[string]int         // 未初始化时为nil映射
m2 := make(map[string]int, 10) // 预分配容量
m3 := map[string]int{"a":1, "b":2}

// 操作
m3["c"] = 3        // 添加/修改
val, ok := m3["d"] // 安全访问（ok表示是否存在）
delete(m3, "a")    // 删除键

3.2.2 底层实现

• 哈希表：Go使用开放寻址法解决哈希冲突
• 无序性：遍历顺序不固定（设计上故意随机化）
• 零值特性：未找到键时返回值类型的零值

3.2.3 并发安全

• 原生map非线程安全，需配合sync.RWMutex：

var mu sync.RWMutex
mu.Lock()
m["key"] = "value"
mu.Unlock()

• sync.Map：适用于读多写少场景（无需锁操作）

3.3 结构体 (Struct)

3.3.1 定义与嵌套

type Person struct {
    Name string
    Age  int
    Address struct {  // 匿名嵌套
        City string
    }
}

// 初始化
p1 := Person{Name: "Alice", Age: 25}
p2 := &Person{Name: "Bob"}  // 结构体指针

3.3.2 标签 (Tag)

type User struct {
    ID   int    `json:"id" db:"user_id"`
    Name string `json:"name" validate:"required"`
}
// 通过反射读取标签
field, _ := reflect.TypeOf(User{}).FieldByName("Name")
fmt.Println(field.Tag.Get("json")) // 输出 "name"

内存对齐优化

// 优化前（占用24字节）
type Bad struct {
    a bool    // 1字节
    b int64   // 8字节
    c int32   // 4字节
}

// 优化后（占用16字节）
type Good struct {
    b int64
    c int32
    a bool
}

使用unsafe.Sizeof()查看结构体大小，调整字段顺序减少内存空洞。

3.4 指针

3.4.1 基本概念

var num int = 42
ptr := &num        // 获取地址
*ptr = 100         // 通过指针修改值
fmt.Println(num)   // 输出100

// 结构体指针可直接访问字段
p := &Person{Name: "Tom"}
fmt.Println(p.Name) // 自动解引用 → "Tom"

3.4.2 指针限制

• 无指针运算：不支持ptr++或ptr-&arr[0]
• 空指针安全：访问nil指针会触发panic
• 栈逃逸分析：编译器自动决定变量分配在栈还是堆

3.5 类型定义与别名

3.5.1 类型定义

type Celsius float64    // 新类型（需显式转换）
type ID string          // 语义化类型定义

var temp Celsius = 36.5
var id ID = "user-123"

// 类型检查严格
// var s string = id  // 编译错误

3.5.2 类型别名

type Float = float64    // 完全等价于原类型
var x Float = 3.14
var y float64 = x       // 无需转换

应用场景对比

总结

本章覆盖了Go语言核心复合类型的底层原理和高级用法，重点包含：

1. 切片扩容策略对性能的影响
2. map的哈希冲突处理与并发安全方案
3. 结构体内存对齐的优化技巧
4. 指针逃逸分析的编译器行为
5. 类型定义与别名的语义化设计

建议通过以下练习巩固知识：

• 实现一个LRU缓存（结合map和双向链表）
• 分析复杂结构体的内存占用（使用unsafe包）
• 对比指针接收者与值接收者的性能差异