1064 lines
24 KiB
Markdown
1064 lines
24 KiB
Markdown
# 第三章：数据结构详解 —— 数组、切片、映射与结构体
|
||
|
||
> **本章目标**：深入理解 Go 的四种核心数据结构，掌握数组与切片的本质区别、映射的底层实现、结构体的组合与嵌入，以及在实际开发中的最佳实践。
|
||
|
||
## 3.1 数组（Arrays）：固定长度的序列
|
||
|
||
### 3.1.1 数组的基本概念
|
||
|
||
数组是**固定长度**的相同类型元素的集合。一旦声明，长度不可改变。
|
||
|
||
```go
|
||
package main
|
||
|
||
import "fmt"
|
||
|
||
func main() {
|
||
// 声明数组（长度是类型的一部分）
|
||
var arr1 [5]int // 5 个 int，初始化为 0
|
||
var arr2 [3]string = {"A", "B", "C"}
|
||
|
||
// 声明并初始化
|
||
arr3 := [4]int{10, 20, 30, 40}
|
||
|
||
// 部分初始化，剩余为 0
|
||
arr4 := [5]int{1, 2} // [1 2 0 0 0]
|
||
|
||
// 使用 ... 自动推断长度
|
||
arr5 := [...]int{1, 2, 3, 4, 5} // [1 2 3 4 5]
|
||
|
||
fmt.Printf("arr1: %v\n", arr1)
|
||
fmt.Printf("arr2: %v\n", arr2)
|
||
fmt.Printf("arr3: %v\n", arr3)
|
||
fmt.Printf("arr4: %v\n", arr4)
|
||
fmt.Printf("arr5: %v\n", arr5)
|
||
}
|
||
```
|
||
|
||
**深度解析**：
|
||
- 数组长度是**类型的一部分**：`[5]int` 和 `[10]int` 是**不同类型**
|
||
- 数组是**值类型**：赋值或传参时会**完整复制**
|
||
- 数组长度**不可变**，这是与切片的核心区别
|
||
|
||
### 3.1.2 数组的访问与遍历
|
||
|
||
```go
|
||
func arrayAccess() {
|
||
arr := [5]int{10, 20, 30, 40, 50}
|
||
|
||
// 访问元素
|
||
fmt.Println(arr[0]) // 10
|
||
fmt.Println(arr[4]) // 50
|
||
// fmt.Println(arr[5]) // panic: index out of range
|
||
|
||
// 修改元素
|
||
arr[1] = 99
|
||
fmt.Println(arr) // [10 99 30 40 50]
|
||
|
||
// 获取长度
|
||
fmt.Println(len(arr)) // 5
|
||
|
||
// 遍历
|
||
for i, v := range arr {
|
||
fmt.Printf("索引 %d: 值 %d\n", i, v)
|
||
}
|
||
|
||
// 只遍历值
|
||
for _, v := range arr {
|
||
fmt.Println(v)
|
||
}
|
||
}
|
||
```
|
||
|
||
### 3.1.3 多维数组
|
||
|
||
```go
|
||
func multiDimensionalArray() {
|
||
// 2x3 的二维数组
|
||
var matrix [2][3]int
|
||
|
||
// 初始化
|
||
matrix = [2][3]int{
|
||
{1, 2, 3},
|
||
{4, 5, 6},
|
||
}
|
||
|
||
// 或者
|
||
matrix := [2][3]int{
|
||
{1, 2, 3},
|
||
{4, 5, 6},
|
||
}
|
||
|
||
// 访问
|
||
fmt.Println(matrix[0][1]) // 2
|
||
fmt.Println(matrix[1][2]) // 6
|
||
|
||
// 遍历
|
||
for i, row := range matrix {
|
||
for j, val := range row {
|
||
fmt.Printf("matrix[%d][%d] = %d\n", i, j, val)
|
||
}
|
||
}
|
||
}
|
||
```
|
||
|
||
### 3.1.4 数组的局限性
|
||
|
||
**问题 1：值复制性能问题**
|
||
```go
|
||
func arrayCopyDemo() {
|
||
arr := [10000]int{}
|
||
// 初始化...
|
||
|
||
// 传参时会复制整个数组（性能差）
|
||
processArray(arr)
|
||
}
|
||
|
||
func processArray(a [10000]int) {
|
||
// 这里接收的是副本
|
||
}
|
||
|
||
// 正确做法：传指针
|
||
func processArrayPtr(a *[10000]int) {
|
||
// 只传递地址
|
||
}
|
||
```
|
||
|
||
**问题 2：长度固定**
|
||
```go
|
||
arr := [5]int{1, 2, 3, 4, 5}
|
||
// arr[5] = 6 // 编译错误！数组长度固定
|
||
```
|
||
|
||
**结论**：在实际开发中，**极少直接使用数组**，更多使用**切片（Slice）**。
|
||
|
||
---
|
||
|
||
## 3.2 切片（Slices）：动态长度的视图
|
||
|
||
切片是 Go 中最常用的数据结构，它是**对数组的动态视图**，提供了灵活的长度和容量管理。
|
||
|
||
### 3.2.1 切片的底层结构
|
||
|
||
切片不是数组，它是一个**描述符**，包含三个字段：
|
||
- `ptr`：指向底层数组的指针
|
||
- `len`：切片长度
|
||
- `cap`：切片容量（从 ptr 开始到数组末尾的长度）
|
||
|
||
```go
|
||
type SliceHeader struct {
|
||
Data uintptr // 指向底层数组
|
||
Len int // 长度
|
||
Cap int // 容量
|
||
}
|
||
```
|
||
|
||
### 3.2.2 切片的创建
|
||
|
||
#### 方式 1：从数组创建
|
||
|
||
```go
|
||
func sliceFromArray() {
|
||
arr := [5]int{1, 2, 3, 4, 5}
|
||
|
||
// 切片语法：arr[start:end]
|
||
s1 := arr[0:3] // [1 2 3], len=3, cap=5
|
||
s2 := arr[1:] // [2 3 4 5], len=4, cap=4
|
||
s3 := arr[:3] // [1 2 3], len=3, cap=5
|
||
s4 := arr[:] // [1 2 3 4 5], len=5, cap=5
|
||
|
||
fmt.Printf("s1: %v, len=%d, cap=%d\n", s1, len(s1), cap(s1))
|
||
fmt.Printf("s2: %v, len=%d, cap=%d\n", s2, len(s2), cap(s2))
|
||
fmt.Printf("s3: %v, len=%d, cap=%d\n", s3, len(s3), cap(s3))
|
||
fmt.Printf("s4: %v, len=%d, cap=%d\n", s4, len(s4), cap(s4))
|
||
|
||
// 修改切片会影响原数组
|
||
s1[0] = 99
|
||
fmt.Println(arr) // [99 2 3 4 5]
|
||
}
|
||
```
|
||
|
||
#### 方式 2：make 创建
|
||
|
||
```go
|
||
func sliceMake() {
|
||
// make([]T, length, capacity)
|
||
s1 := make([]int, 5) // len=5, cap=5, 元素为 0
|
||
s2 := make([]int, 3, 10) // len=3, cap=10, 元素为 0
|
||
|
||
fmt.Printf("s1: %v, len=%d, cap=%d\n", s1, len(s1), cap(s1))
|
||
fmt.Printf("s2: %v, len=%d, cap=%d\n", s2, len(s2), cap(s2))
|
||
|
||
// 直接初始化
|
||
s3 := []int{1, 2, 3, 4, 5} // len=5, cap=5
|
||
s4 := []string{"a", "b", "c"} // len=3, cap=3
|
||
}
|
||
```
|
||
|
||
#### 方式 3：字面量创建
|
||
|
||
```go
|
||
func sliceLiteral() {
|
||
s := []int{1, 2, 3, 4, 5}
|
||
fmt.Printf("s: %v, len=%d, cap=%d\n", s, len(s), cap(s))
|
||
}
|
||
```
|
||
|
||
### 3.2.3 切片的操作
|
||
|
||
#### append：追加元素
|
||
|
||
```go
|
||
func sliceAppend() {
|
||
s := []int{1, 2, 3}
|
||
|
||
// 追加单个元素
|
||
s = append(s, 4)
|
||
fmt.Println(s) // [1 2 3 4]
|
||
|
||
// 追加多个元素
|
||
s = append(s, 5, 6, 7)
|
||
fmt.Println(s) // [1 2 3 4 5 6 7]
|
||
|
||
// 追加另一个切片
|
||
s2 := []int{8, 9, 10}
|
||
s = append(s, s2...) // 必须加 ... 展开
|
||
fmt.Println(s) // [1 2 3 4 5 6 7 8 9 10]
|
||
|
||
// 容量变化
|
||
s3 := make([]int, 0, 5)
|
||
fmt.Printf("初始：len=%d, cap=%d\n", len(s3), cap(s3))
|
||
|
||
for i := 1; i <= 10; i++ {
|
||
s3 = append(s3, i)
|
||
fmt.Printf("追加 %d: len=%d, cap=%d\n", i, len(s3), cap(s3))
|
||
}
|
||
}
|
||
```
|
||
|
||
**深度解析**：
|
||
- `append` 会返回**新切片**，必须接收返回值
|
||
- 当 `len < cap` 时，直接在底层数组追加
|
||
- 当 `len == cap` 时，会**重新分配更大的数组**并复制
|
||
- 扩容策略：
|
||
- 容量 < 1024：翻倍
|
||
- 容量 >= 1024：增长约 25%
|
||
|
||
#### copy：复制切片
|
||
|
||
```go
|
||
func sliceCopy() {
|
||
src := []int{1, 2, 3, 4, 5}
|
||
dst := make([]int, 3)
|
||
|
||
n := copy(dst, src) // 复制 min(len(dst), len(src)) 个元素
|
||
fmt.Printf("复制了 %d 个元素\n", n)
|
||
fmt.Printf("dst: %v\n", dst) // [1 2 3]
|
||
|
||
// 从指定位置复制
|
||
dst2 := make([]int, 5)
|
||
copy(dst2[1:], src)
|
||
fmt.Printf("dst2: %v\n", dst2) // [0 1 2 3 4]
|
||
}
|
||
```
|
||
|
||
#### 切片切片（Slicing the slice）
|
||
|
||
```go
|
||
func sliceSlicing() {
|
||
s := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
|
||
|
||
s1 := s[2:5] // [3 4 5], len=3, cap=8
|
||
s2 := s1[1:3] // [4 5], len=2, cap=6（从 s1[1] 开始，到原数组末尾）
|
||
|
||
fmt.Printf("s: %v\n", s)
|
||
fmt.Printf("s1: %v, len=%d, cap=%d\n", s1, len(s1), cap(s1))
|
||
fmt.Printf("s2: %v, len=%d, cap=%d\n", s2, len(s2), cap(s2))
|
||
|
||
// 修改 s2 会影响 s
|
||
s2[0] = 99
|
||
fmt.Printf("s 修改后：%v\n", s) // [1 2 3 99 5 6 7 8 9 10]
|
||
}
|
||
```
|
||
|
||
**深度解析**：
|
||
- 切片的容量是从**当前起始位置到原数组末尾**
|
||
- 多次切片后，容量可能很大，导致内存无法释放
|
||
- **最佳实践**：如果不再需要原数组，使用 `append` 创建新切片
|
||
|
||
```go
|
||
// 释放内存的正确方式
|
||
func trimMemory(s []int) []int {
|
||
result := append([]int(nil), s[:3]...) // 创建新切片，只包含前 3 个元素
|
||
return result
|
||
}
|
||
```
|
||
|
||
### 3.2.4 切片的常见陷阱
|
||
|
||
#### 陷阱 1：共享底层数组
|
||
|
||
```go
|
||
func sharedUnderlyingArray() {
|
||
s1 := []int{1, 2, 3, 4, 5}
|
||
s2 := s1[1:3]
|
||
|
||
s2[0] = 99
|
||
fmt.Println(s1) // [1 99 3 4 5] // s1 也被修改了！
|
||
fmt.Println(s2) // [99 3]
|
||
}
|
||
```
|
||
|
||
#### 陷阱 2：容量陷阱导致内存泄漏
|
||
|
||
```go
|
||
func capacityLeak() {
|
||
data := make([]int, 1000000) // 大数组
|
||
// 处理数据...
|
||
|
||
// 错误：只取前 10 个，但容量仍为 1000000
|
||
small := data[:10]
|
||
// small 持有整个大数组的引用，内存无法释放
|
||
|
||
// 正确：创建新切片
|
||
small := append([]int(nil), data[:10]...)
|
||
// 现在 data 可以被垃圾回收
|
||
}
|
||
```
|
||
|
||
#### 陷阱 3：append 后的长度变化
|
||
|
||
```go
|
||
func appendLengthChange() {
|
||
s := make([]int, 3)
|
||
s[0], s[1], s[2] = 1, 2, 3
|
||
|
||
s = append(s, 4, 5, 6)
|
||
// s 现在是 [1 2 3 4 5 6], len=6
|
||
|
||
// 如果继续用原来的索引访问会 panic
|
||
// s[3] = 7 // 正确
|
||
// s[10] = 8 // panic: index out of range
|
||
}
|
||
```
|
||
|
||
### 3.2.5 切片的高级用法
|
||
|
||
#### 使用切片作为函数参数
|
||
|
||
```go
|
||
func processSlice(s []int) {
|
||
// 修改会影响原切片（因为共享底层数组）
|
||
for i := range s {
|
||
s[i] *= 2
|
||
}
|
||
}
|
||
|
||
func main() {
|
||
s := []int{1, 2, 3}
|
||
processSlice(s)
|
||
fmt.Println(s) // [2 4 6]
|
||
}
|
||
```
|
||
|
||
#### 切片推导（Slice Comprehension）
|
||
|
||
Go 没有像 Python 那样的列表推导式，但可以用循环实现：
|
||
|
||
```go
|
||
func sliceComprehension() {
|
||
nums := []int{1, 2, 3, 4, 5}
|
||
|
||
// 平方
|
||
squares := make([]int, 0, len(nums))
|
||
for _, n := range nums {
|
||
squares = append(squares, n*n)
|
||
}
|
||
fmt.Println(squares) // [1 4 9 16 25]
|
||
|
||
// 过滤偶数
|
||
evens := make([]int, 0)
|
||
for _, n := range nums {
|
||
if n%2 == 0 {
|
||
evens = append(evens, n)
|
||
}
|
||
}
|
||
fmt.Println(evens) // [2 4]
|
||
}
|
||
```
|
||
|
||
---
|
||
|
||
## 3.3 映射（Maps）：键值对的集合
|
||
|
||
映射是 Go 中的**哈希表**实现，提供 O(1) 的平均查找时间。
|
||
|
||
### 3.3.1 映射的创建与初始化
|
||
|
||
```go
|
||
func mapCreation() {
|
||
// 方式 1：make 创建
|
||
m1 := make(map[string]int)
|
||
m1["one"] = 1
|
||
m1["two"] = 2
|
||
|
||
// 方式 2：字面量初始化
|
||
m2 := map[string]int{
|
||
"one": 1,
|
||
"two": 2,
|
||
"three": 3,
|
||
}
|
||
|
||
// 方式 3：空映射
|
||
m3 := map[string]int{}
|
||
|
||
// nil 映射（不能写入）
|
||
var m4 map[string]int
|
||
// m4["five"] = 5 // panic: assignment to entry in nil map
|
||
|
||
fmt.Printf("m1: %v\n", m1)
|
||
fmt.Printf("m2: %v\n", m2)
|
||
fmt.Printf("m3: %v\n", m3)
|
||
}
|
||
```
|
||
|
||
### 3.3.2 映射的基本操作
|
||
|
||
```go
|
||
func mapOperations() {
|
||
m := map[string]int{
|
||
"apple": 5,
|
||
"banana": 3,
|
||
"orange": 8,
|
||
}
|
||
|
||
// 读取
|
||
fmt.Println(m["apple"]) // 5
|
||
|
||
// 写入
|
||
m["grape"] = 10
|
||
m["apple"] = 7 // 更新
|
||
|
||
// 删除
|
||
delete(m, "banana")
|
||
|
||
// 检查键是否存在（重要！）
|
||
value, exists := m["orange"]
|
||
if exists {
|
||
fmt.Printf("orange 存在，价格：%d\n", value)
|
||
}
|
||
|
||
// 读取不存在的键，返回零值
|
||
fmt.Println(m["mango"]) // 0（int 的零值）
|
||
|
||
// 遍历（无序！）
|
||
for fruit, price := range m {
|
||
fmt.Printf("%s: %d\n", fruit, price)
|
||
}
|
||
|
||
// 只遍历键
|
||
for fruit := range m {
|
||
fmt.Println(fruit)
|
||
}
|
||
|
||
// 只遍历值
|
||
for _, price := range m {
|
||
fmt.Println(price)
|
||
}
|
||
}
|
||
```
|
||
|
||
### 3.3.3 映射的底层原理
|
||
|
||
**深度解析**：
|
||
- 映射是**引用类型**，底层指向一个 `hmap` 结构
|
||
- 映射是**无序**的，每次遍历顺序可能不同（故意设计，防止依赖顺序）
|
||
- 映射**不是并发安全**的，多线程读写会 panic
|
||
- 映射的容量会自动增长，但**不会自动缩小**
|
||
|
||
```go
|
||
// 并发安全的映射
|
||
func concurrentMap() {
|
||
var m sync.Map // 或使用 sync.RWMutex 保护普通 map
|
||
|
||
m.Store("key", "value")
|
||
val, _ := m.Load("key")
|
||
fmt.Println(val)
|
||
}
|
||
```
|
||
|
||
### 3.3.4 映射的常见陷阱
|
||
|
||
#### 陷阱 1：遍历无序
|
||
|
||
```go
|
||
func mapUnordered() {
|
||
m := map[int]string{
|
||
1: "one",
|
||
2: "two",
|
||
3: "three",
|
||
}
|
||
|
||
for i := 0; i < 5; i++ {
|
||
for k, v := range m {
|
||
fmt.Printf("%d:%s ", k, v)
|
||
}
|
||
fmt.Println()
|
||
}
|
||
// 每次输出顺序都不同！
|
||
}
|
||
```
|
||
|
||
#### 陷阱 2：nil 映射
|
||
|
||
```go
|
||
func mapNil() {
|
||
var m map[string]int // nil 映射
|
||
|
||
// 读取没问题（返回零值）
|
||
fmt.Println(m["key"]) // 0
|
||
|
||
// 写入会 panic
|
||
// m["key"] = 1 // panic: assignment to entry in nil map
|
||
|
||
// 正确做法
|
||
m = make(map[string]int)
|
||
m["key"] = 1
|
||
}
|
||
```
|
||
|
||
#### 陷阱 3：映射作为函数参数
|
||
|
||
```go
|
||
func modifyMap(m map[string]int) {
|
||
m["new"] = 100 // 修改会影响原映射
|
||
}
|
||
|
||
func main() {
|
||
m := make(map[string]int)
|
||
modifyMap(m)
|
||
fmt.Println(m) // map[new:100]
|
||
}
|
||
```
|
||
|
||
### 3.3.5 高级用法：嵌套映射
|
||
|
||
```go
|
||
func nestedMap() {
|
||
// 映射的映射
|
||
scores := map[string]map[string]int{
|
||
"Alice": {
|
||
"math": 95,
|
||
"english": 88,
|
||
},
|
||
"Bob": {
|
||
"math": 92,
|
||
"english": 90,
|
||
},
|
||
}
|
||
|
||
// 访问
|
||
fmt.Println(scores["Alice"]["math"]) // 95
|
||
|
||
// 动态创建
|
||
if scores["Charlie"] == nil {
|
||
scores["Charlie"] = make(map[string]int)
|
||
}
|
||
scores["Charlie"]["math"] = 85
|
||
|
||
// 遍历
|
||
for name, subjects := range scores {
|
||
fmt.Printf("%s:\n", name)
|
||
for subject, score := range subjects {
|
||
fmt.Printf(" %s: %d\n", subject, score)
|
||
}
|
||
}
|
||
}
|
||
```
|
||
|
||
---
|
||
|
||
## 3.4 结构体（Structs）：自定义类型
|
||
|
||
结构体是 Go 中**组合数据**的方式，类似其他语言的类（但没有继承）。
|
||
|
||
### 3.4.1 结构体的定义与初始化
|
||
|
||
```go
|
||
func structDefinition() {
|
||
// 定义结构体
|
||
type Person struct {
|
||
Name string
|
||
Age int
|
||
Email string
|
||
}
|
||
|
||
// 方式 1：字面量初始化（推荐）
|
||
p1 := Person{
|
||
Name: "Alice",
|
||
Age: 25,
|
||
Email: "alice@example.com",
|
||
}
|
||
|
||
// 方式 2：位置初始化（不推荐，易错）
|
||
p2 := Person{"Bob", 30, "bob@example.com"}
|
||
|
||
// 方式 3：部分初始化
|
||
p3 := Person{Name: "Charlie"} // Age=0, Email=""
|
||
|
||
// 方式 4：new（返回指针）
|
||
p4 := new(Person)
|
||
p4.Name = "David"
|
||
p4.Age = 28
|
||
|
||
// 方式 5：取地址
|
||
p5 := &Person{Name: "Eve", Age: 22}
|
||
|
||
fmt.Printf("p1: %+v\n", p1)
|
||
fmt.Printf("p2: %+v\n", p2)
|
||
fmt.Printf("p3: %+v\n", p3)
|
||
fmt.Printf("p4: %+v\n", *p4)
|
||
fmt.Printf("p5: %+v\n", *p5)
|
||
}
|
||
```
|
||
|
||
### 3.4.2 结构体字段访问
|
||
|
||
```go
|
||
func structAccess() {
|
||
type Point struct {
|
||
X float64
|
||
Y float64
|
||
}
|
||
|
||
p := Point{X: 10.5, Y: 20.3}
|
||
|
||
// 值访问
|
||
fmt.Println(p.X) // 10.5
|
||
p.X = 15.0
|
||
|
||
// 指针访问（自动解引用）
|
||
ptr := &p
|
||
fmt.Println(ptr.X) // 15.0（不需要 ptr->X）
|
||
ptr.Y = 25.0
|
||
|
||
fmt.Printf("p: %+v\n", p) // {X:15 Y:25}
|
||
}
|
||
```
|
||
|
||
### 3.4.3 结构体方法
|
||
|
||
```go
|
||
func structMethods() {
|
||
type Rectangle struct {
|
||
Width float64
|
||
Height float64
|
||
}
|
||
|
||
// 值接收者方法
|
||
func (r Rectangle) Area() float64 {
|
||
return r.Width * r.Height
|
||
}
|
||
|
||
// 指针接收者方法（可以修改结构体）
|
||
func (r *Rectangle) Scale(factor float64) {
|
||
r.Width *= factor
|
||
r.Height *= factor
|
||
}
|
||
|
||
rect := Rectangle{Width: 10, Height: 5}
|
||
fmt.Printf("面积：%.2f\n", rect.Area()) // 50.00
|
||
|
||
rect.Scale(2.0)
|
||
fmt.Printf("缩放后面积：%.2f\n", rect.Area()) // 200.00
|
||
}
|
||
```
|
||
|
||
**深度解析**：
|
||
- **值接收者**：方法接收结构体的副本，不能修改原结构体
|
||
- **指针接收者**：方法接收结构体的指针，可以修改原结构体
|
||
- 如果方法需要修改接收者，必须使用**指针接收者**
|
||
- 如果方法只读取，可以使用**值接收者**（小结构体）或**指针接收者**（大结构体，避免复制）
|
||
|
||
### 3.4.4 结构体嵌入（组合）
|
||
|
||
Go 没有继承，但通过**嵌入**实现类似功能。
|
||
|
||
```go
|
||
func structEmbedding() {
|
||
// 基础结构体
|
||
type Person struct {
|
||
Name string
|
||
Age int
|
||
}
|
||
|
||
func (p Person) SayHello() {
|
||
fmt.Printf("你好，我是 %s\n", p.Name)
|
||
}
|
||
|
||
// 嵌入结构体
|
||
type Employee struct {
|
||
Person // 匿名嵌入
|
||
ID int
|
||
Salary float64
|
||
}
|
||
|
||
e := Employee{
|
||
Person: Person{Name: "Alice", Age: 30},
|
||
ID: 1001,
|
||
Salary: 50000,
|
||
}
|
||
|
||
// 直接访问嵌入字段
|
||
fmt.Println(e.Name) // "Alice"（等价于 e.Person.Name）
|
||
fmt.Println(e.Age) // 30
|
||
|
||
// 调用嵌入方法
|
||
e.SayHello() // "你好，我是 Alice"
|
||
|
||
// 方法重写
|
||
type Manager struct {
|
||
Employee
|
||
TeamSize int
|
||
}
|
||
|
||
// Manager 也继承了 SayHello 方法
|
||
m := Manager{
|
||
Employee: Employee{
|
||
Person: Person{Name: "Bob", Age: 40},
|
||
ID: 2001,
|
||
Salary: 80000,
|
||
},
|
||
TeamSize: 10,
|
||
}
|
||
|
||
m.SayHello() // "你好，我是 Bob"
|
||
}
|
||
```
|
||
|
||
### 3.4.5 结构体标签（Tags）
|
||
|
||
结构体标签用于元数据，常用于 JSON、数据库映射等。
|
||
|
||
```go
|
||
func structTags() {
|
||
type User struct {
|
||
ID int `json:"id" db:"user_id"`
|
||
Name string `json:"name" validate:"required"`
|
||
Email string `json:"email,omitempty"`
|
||
Password string `json:"-"` // 忽略此字段
|
||
Age int `json:"age" validate:"min=18"`
|
||
}
|
||
|
||
u := User{
|
||
ID: 1,
|
||
Name: "Alice",
|
||
Email: "alice@example.com",
|
||
Password: "secret123",
|
||
Age: 25,
|
||
}
|
||
|
||
// JSON 序列化
|
||
jsonData, _ := json.Marshal(u)
|
||
fmt.Println(string(jsonData))
|
||
// 输出：{"id":1,"name":"Alice","email":"alice@example.com","age":25}
|
||
// Password 被忽略（json:"-")
|
||
// Email 即使为空也会输出（没有 omitempty 时）
|
||
}
|
||
```
|
||
|
||
### 3.4.6 结构体比较
|
||
|
||
```go
|
||
func structComparison() {
|
||
type Point struct {
|
||
X int
|
||
Y int
|
||
}
|
||
|
||
p1 := Point{X: 1, Y: 2}
|
||
p2 := Point{X: 1, Y: 2}
|
||
p3 := Point{X: 1, Y: 3}
|
||
|
||
fmt.Println(p1 == p2) // true
|
||
fmt.Println(p1 == p3) // false
|
||
|
||
// 包含不可比较字段的结构体不能比较
|
||
type Data struct {
|
||
Name string
|
||
List []int // 切片不可比较
|
||
}
|
||
|
||
// d1 := Data{Name: "a", List: []int{1}}
|
||
// d2 := Data{Name: "a", List: []int{1}}
|
||
// fmt.Println(d1 == d2) // 编译错误！
|
||
}
|
||
```
|
||
|
||
---
|
||
|
||
## 3.5 深度实践：综合案例
|
||
|
||
### 3.5.1 学生管理系统
|
||
|
||
```go
|
||
package main
|
||
|
||
import (
|
||
"encoding/json"
|
||
"fmt"
|
||
"sort"
|
||
)
|
||
|
||
// 学生结构体
|
||
type Student struct {
|
||
ID int `json:"id"`
|
||
Name string `json:"name"`
|
||
Age int `json:"age"`
|
||
Score float64 `json:"score"`
|
||
}
|
||
|
||
// 学生管理系统
|
||
type StudentManager struct {
|
||
students map[int]*Student
|
||
nextID int
|
||
}
|
||
|
||
// 创建管理系统
|
||
func NewStudentManager() *StudentManager {
|
||
return &StudentManager{
|
||
students: make(map[int]*Student),
|
||
nextID: 1,
|
||
}
|
||
}
|
||
|
||
// 添加学生
|
||
func (sm *StudentManager) AddStudent(name string, age int, score float64) int {
|
||
id := sm.nextID
|
||
sm.nextID++
|
||
|
||
sm.students[id] = &Student{
|
||
ID: id,
|
||
Name: name,
|
||
Age: age,
|
||
Score: score,
|
||
}
|
||
|
||
return id
|
||
}
|
||
|
||
// 获取学生
|
||
func (sm *StudentManager) GetStudent(id int) *Student {
|
||
return sm.students[id]
|
||
}
|
||
|
||
// 更新学生
|
||
func (sm *StudentManager) UpdateStudent(id int, name string, age int, score float64) bool {
|
||
if student, exists := sm.students[id]; exists {
|
||
student.Name = name
|
||
student.Age = age
|
||
student.Score = score
|
||
return true
|
||
}
|
||
return false
|
||
}
|
||
|
||
// 删除学生
|
||
func (sm *StudentManager) DeleteStudent(id int) bool {
|
||
if _, exists := sm.students[id]; exists {
|
||
delete(sm.students, id)
|
||
return true
|
||
}
|
||
return false
|
||
}
|
||
|
||
// 获取所有学生
|
||
func (sm *StudentManager) GetAllStudents() []*Student {
|
||
students := make([]*Student, 0, len(sm.students))
|
||
for _, s := range sm.students {
|
||
students = append(students, s)
|
||
}
|
||
return students
|
||
}
|
||
|
||
// 按分数排序
|
||
func (sm *StudentManager) SortByScore(descending bool) []*Student {
|
||
students := sm.GetAllStudents()
|
||
sort.Slice(students, func(i, j int) bool {
|
||
if descending {
|
||
return students[i].Score > students[j].Score
|
||
}
|
||
return students[i].Score < students[j].Score
|
||
})
|
||
return students
|
||
}
|
||
|
||
// 导出为 JSON
|
||
func (sm *StudentManager) ExportJSON() (string, error) {
|
||
data, err := json.MarshalIndent(sm.students, "", " ")
|
||
if err != nil {
|
||
return "", err
|
||
}
|
||
return string(data), nil
|
||
}
|
||
|
||
func main() {
|
||
manager := NewStudentManager()
|
||
|
||
// 添加学生
|
||
id1 := manager.AddStudent("Alice", 20, 95.5)
|
||
id2 := manager.AddStudent("Bob", 22, 88.0)
|
||
id3 := manager.AddStudent("Charlie", 21, 92.5)
|
||
|
||
fmt.Printf("添加学生 ID: %d, %d, %d\n", id1, id2, id3)
|
||
|
||
// 获取学生
|
||
student := manager.GetStudent(id1)
|
||
fmt.Printf("学生： %+v\n", student)
|
||
|
||
// 更新学生
|
||
manager.UpdateStudent(id1, "Alice", 21, 97.0)
|
||
fmt.Printf("更新后： %+v\n", manager.GetStudent(id1))
|
||
|
||
// 删除学生
|
||
manager.DeleteStudent(id2)
|
||
fmt.Printf("删除后学生数量：%d\n", len(manager.GetAllStudents()))
|
||
|
||
// 排序
|
||
sorted := manager.SortByScore(true)
|
||
fmt.Println("\n按分数降序排列:")
|
||
for _, s := range sorted {
|
||
fmt.Printf(" %s: %.1f\n", s.Name, s.Score)
|
||
}
|
||
|
||
// 导出 JSON
|
||
jsonStr, _ := manager.ExportJSON()
|
||
fmt.Println("\nJSON 导出:")
|
||
fmt.Println(jsonStr)
|
||
}
|
||
```
|
||
|
||
### 3.5.2 切片性能优化对比
|
||
|
||
```go
|
||
func slicePerformance() {
|
||
// 预分配容量（推荐）
|
||
start := time.Now()
|
||
s1 := make([]int, 0, 10000)
|
||
for i := 0; i < 10000; i++ {
|
||
s1 = append(s1, i)
|
||
}
|
||
fmt.Printf("预分配容量耗时：%v\n", time.Since(start))
|
||
|
||
// 不预分配容量（慢）
|
||
start = time.Now()
|
||
s2 := make([]int, 0)
|
||
for i := 0; i < 10000; i++ {
|
||
s2 = append(s2, i)
|
||
}
|
||
fmt.Printf("不预分配容量耗时：%v\n", time.Since(start))
|
||
|
||
// 输出：预分配通常快 2-3 倍
|
||
}
|
||
```
|
||
|
||
---
|
||
|
||
## 3.6 常见陷阱与最佳实践
|
||
|
||
### 3.6.1 数组 vs 切片
|
||
|
||
| 特性 | 数组 | 切片 |
|
||
|------|------|------|
|
||
| 长度 | 固定 | 动态 |
|
||
| 类型 | 长度是类型一部分 | 无长度限制 |
|
||
| 传参 | 完整复制 | 只传描述符 |
|
||
| 使用场景 | 固定大小、性能敏感 | 通用、推荐 |
|
||
|
||
**最佳实践**：99% 的场景使用切片，数组仅在特殊场景（如性能极致优化、固定大小缓冲区）使用。
|
||
|
||
### 3.6.2 切片内存泄漏
|
||
|
||
```go
|
||
// 错误：切片持有大数组引用
|
||
func badPractice(data []byte) []byte {
|
||
return data[:10] // 持有整个 data 的引用
|
||
}
|
||
|
||
// 正确：创建新切片
|
||
func goodPractice(data []byte) []byte {
|
||
result := make([]byte, 10)
|
||
copy(result, data[:10])
|
||
return result
|
||
}
|
||
// 或者
|
||
func goodPractice2(data []byte) []byte {
|
||
return append([]byte(nil), data[:10]...)
|
||
}
|
||
```
|
||
|
||
### 3.6.3 映射并发安全
|
||
|
||
```go
|
||
// 错误：并发读写
|
||
var m = make(map[string]int)
|
||
|
||
func worker() {
|
||
for i := 0; i < 1000; i++ {
|
||
m["key"] = i // panic: concurrent map writes
|
||
}
|
||
}
|
||
|
||
// 正确：使用 sync.Mutex
|
||
var (
|
||
m = make(map[string]int)
|
||
mu sync.RWMutex
|
||
)
|
||
|
||
func workerSafe() {
|
||
for i := 0; i < 1000; i++ {
|
||
mu.Lock()
|
||
m["key"] = i
|
||
mu.Unlock()
|
||
}
|
||
}
|
||
|
||
// 或者使用 sync.Map
|
||
var sm sync.Map
|
||
|
||
func workerSyncMap() {
|
||
for i := 0; i < 1000; i++ {
|
||
sm.Store("key", i)
|
||
}
|
||
}
|
||
```
|
||
|
||
### 3.6.4 结构体最佳实践
|
||
|
||
1. **使用指针接收者**：除非结构体很小且不需要修改
|
||
2. **避免嵌入指针**：优先嵌入值，除非需要 nil 语义
|
||
3. **使用标签**：为 JSON、数据库等添加元数据
|
||
4. **导出字段**：首字母大写才能被外部访问
|
||
5. **组合优于继承**：通过嵌入实现代码复用
|
||
|
||
---
|
||
|
||
## 3.7 课后练习
|
||
|
||
1. **切片操作**：实现一个函数，移除切片中的重复元素
|
||
2. **映射统计**：统计字符串中每个字符出现的次数
|
||
3. **结构体链式调用**：为结构体实现链式调用方法
|
||
4. **性能优化**：对比预分配容量和不预分配的切片性能差异
|
||
5. **并发安全**：实现一个线程安全的计数器（使用映射）
|
||
6. **综合项目**：实现一个简单的待办事项管理器（支持增删改查、排序、导出）
|
||
|
||
## 3.8 下一步
|
||
|
||
完成本章后，你将进入第四章：**函数与接口**，深入学习 Go 的函数式编程特性、闭包、 defer、panic/recover 以及接口的底层实现。
|
||
|
||
---
|
||
|
||
**代码仓库位置**：https://giter.top/openclaw/test/tree/main/chapters/chapter-3
|
||
|
||
**下一章预告**：闭包的高级用法、defer 的执行顺序、接口的空接口与类型断言、接口底层实现
|