05.2 阶段 1 语言基础与数据类型
本页目录
一、阶段定位
阶段 0 只解决"能在本机编译并运行一个 main 包"的问题:装好 Go、认得出 go env 的几项关键变量、会用 Git 提交。本阶段开始真正接触 Go 的语言模型,重点不是"语法有多少",而是 Go 与 Java、PHP、Python 在数据表示上的三处硬差异:
- 零值可用:变量不需要显式初始化就能安全使用,
var s []int得到的是 nil slice 而不是"未定义",len(s)返回 0,append能正常工作。 - 值语义是默认:赋值、传参、
range循环默认复制,指针必须显式写*。想清楚"这里复制了几次、多大",是 Go 性能问题的起点。 - slice 不是数组:slice 是"指针 + 长度 + 容量"的三字段结构,
append可能原地扩容,也可能换一块新内存,这决定了什么时候会出现"改了 A 却影响 B"。
本阶段与前后阶段的衔接:往下接阶段 2 的类型系统与错误处理(接口、泛型、error 包装、工程约定),那时讨论的不再是"能不能写出来",而是"接口边界怎么划、错误怎么传"。往上承接阶段 0 的工具链,本阶段要真正用上 go mod、go vet、go test、go build -race。跳过 slice 与 map 的底层理解直接进并发阶段,后面遇到"多个 goroutine 共享同一个底层数组"的数据竞争时会完全无从下手。
二、阶段目标与投入
学完本页,应当能用可观察的行为证明以下六条能力,而不是"看过教程":
| 能力目标(可验证的行为) | 验证方式 |
|---|---|
能独立搭出一个带 go.mod、多包、有单元测试的命令行工程 |
go build ./...、go test ./... 均无报错 |
| 能解释并演示 slice 共享底层数组导致的写入互相影响 | 用两个 slice 变量改同一块数据,打印出意外结果后能说清原因 |
| 能用值接收者与指针接收者正确实现一组方法,并说明选择依据 | 出现"改了结构体字段但调用方看不到"时能一次定位 |
能处理 UTF-8 文本,区分 len(s) 与 utf8.RuneCountInString |
对含中文的字符串做截取、填充不发生乱码 |
| 能说明 map 的哈希桶结构、扩容时机与"为什么不能并发写" | 手写一个触发 fatal error: concurrent map writes 的最小复现 |
能用 defer、命名返回值、recover 写出资源释放与错误转换 |
写一个"打开文件失败也要关闭已打开句柄"的函数 |
建议学时:
- 全职(每天有效学习 4–6 小时):2 周,约 60–70 小时。其中读文档 20 小时、写代码 40 小时、复盘 10 小时。
- 在职(每天 2 小时、周末补 4 小时):5–6 周,约 70 小时。按"一个模块两天"的节奏排,不要一次看完全部模块再动手。
学时分配建议:包与工程骨架 10%、变量与零值 10%、基本类型与字符串 20%、指针与 struct 20%、slice 20%、map 15%、defer 与控制流 5%。slice 与 map 是面试与线上问题的重灾区,时间要给够。
三、先修自检
进入本阶段前,逐条自检;任何一条做不到,先回到对应页面补齐,否则后面的示例会看不懂。
| 先修项 | 合格标准 | 不合格时回到 |
|---|---|---|
| 命令行与文件操作 | 能在终端里 cd、查看文件、用编辑器保存文件、看懂绝对路径与相对路径 |
05.1 阶段 0 环境与基础准备 |
| Git 基本操作 | 能 git init、git add、git commit,看懂 git status 输出 |
05.1 阶段 0 环境与基础准备 |
| 程序基本结构 | 知道什么是变量、函数、返回值、编译与运行 | 05.1 阶段 0 环境与基础准备 |
| Go 工具链可用 | go version、go env GOPATH、go run hello.go 都能正常输出 |
05.1 阶段 0 环境与基础准备 |
| 十六进制与字节概念 | 知道 1 字节 = 8 位,能看懂 0x41 这类字面量 |
05.1 阶段 0 环境与基础准备 |
另有一条经验判断:如果你写过 C 或 C++,本阶段最容易犯的错是"把 Go 当 C 写"——到处传指针、手动管理内存、用数组思维写 slice。写过 Java 的人容易把 map 当 HashMap 用,忽略它不能并发写。这两类偏差都要在练习里主动纠正。
四、知识地图
"掌握程度"分三档:了解(知道有这个东西、能查到)、会用(能写对、能调通)、能讲清原理(能解释底层结构与边界条件、能回答追问)。本阶段的目标分布如下。
| 模块 | 知识点 | 掌握程度 | 对应题库章节 |
|---|---|---|---|
| 包与模块 | go.mod、module path、internal/ 可见性、包名与目录名关系 |
会用 | 04.3 Go |
| 变量与零值 | var / := / 常量 / iota、各类型零值、const 无类型常量 |
能讲清原理 | 04.3 Go |
| 基本类型 | 整型宽度与溢出、float64 精度、类型转换规则、unsafe.Sizeof |
会用 | 04.3 Go |
| 字符串与 rune | string 不可变、[]byte 与 []rune 转换代价、strings.Builder |
能讲清原理 | 04.3 Go |
| 指针与 struct | 值接收者与指针接收者、结构体对齐与内存占用、嵌入字段 | 能讲清原理 | 04.3 Go |
| slice | 三字段结构、append 扩容策略、共享底层数组、copy 与三索引切片 |
能讲清原理 | 04.3 Go |
| map | 哈希桶、负载因子与渐进式扩容、并发写检测、删除与遍历顺序 | 能讲清原理 | 04.3 Go |
| 控制流与 defer | for 三种写法、switch 无穿透、defer 求值时机与栈顺序、recover 边界 |
能讲清原理 | 04.3 Go |
进度管理建议:把这张表复制到自己的笔记里,每学完一个模块把"掌握程度"往下调一档;三档都到位再进阶段 2。《知识点全清单》是本篇更细的全量清单,与此表的分工是"全量打勾"与"本阶段重点"。
五、分模块精讲
5.1 包、模块与工程骨架
为什么需要它:Go 没有"类路径"和"命名空间"的概念,代码组织完全靠模块路径 + 包名。没搞清楚 go.mod 的 module path 与 import 路径的关系,第一次引入自己的子包就会得到 cannot find package。
核心机制:
go.mod第一行module example.com/notes定义了本模块的导入前缀。子包store/的导入路径是example.com/notes/store。- 一个目录 = 一个包,目录内所有
.go文件的package声明必须一致(main包除外,它必须放在可执行目录)。 - 包名可以与目录名不同(目录
store、包名storage都合法),但导入后使用的名字是包名。 - 包级标识符首字母大写才导出;
internal/目录下的包只能被同一模块内、internal的父目录以内的包导入。 main包必须有func main(),且不能有init之外的导出需求。
最小可运行示例:
# 建立工程骨架,全程可在任意目录执行
mkdir -p notes/cmd/notes notes/store notes/internal/util
cd notes
go mod init example.com/notes # 写入 go.mod,Go 版本行会自动带上本机版本
go mod tidy # 拉取并整理依赖,无依赖时也会整理 go.sum
go build ./... # 编译所有包,不产出二进制
go vet ./... # 静态检查
// notes/internal/util/id.go
package util
import (
"fmt"
"time"
)
// NewID 生成一个带时间戳前缀的简易 ID,便于日志排查先后顺序。
func NewID(seq int) string {
return fmt.Sprintf("%d-%03d", time.Now().UnixMilli(), seq)
}
// notes/cmd/notes/main.go
package main
import (
"fmt"
"example.com/notes/internal/util"
"example.com/notes/store"
)
func main() {
s := store.NewMemoryStore()
s.Put("k1", "hello")
// internal 包只有本模块内可导入,外部模块引用会编译失败
fmt.Println(util.NewID(1), s.Get("k1"))
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
cannot find package "example.com/notes/store" |
目录存在但该目录下文件没有 package store,或路径拼错 |
确认目录内 .go 文件的 package 声明;用 go list ./... 看真实包列表 |
found packages a and b in ... |
同一目录下两个文件的 package 名不一致 | 统一为一个包名;测试文件可用 _test 后缀包名 |
引入本地另一个模块后报 missing go.sum entry |
依赖未写入 go.sum |
go mod tidy 后重新编译 |
修改了代码但 go run 用的是旧结果 |
用的是旧的二进制或 IDE 缓存 | go build -a 强制重编;确认运行的确实是当前目录的包 |
面试考法:常见问法是"Go 的包管理和 Java 的 Maven、Node 的 npm 有什么不同"。要答到"模块路径即导入前缀,版本由 go.mod 的 require 与 go.sum 校验和共同固定;没有中央仓库强绑定,直接从 VCS 拉取,靠 GOPROXY 做代理与缓存"。追问常落在 internal 的可见性边界与 vendor 目录的作用上。
5.2 变量、常量与零值语义
为什么需要它:Go 没有"未初始化"这个状态,任何变量都有确定的零值。不理解这一点,会把"字段是空字符串"误判成"字段没设置",也会写出一堆无意义的初始化代码。
核心机制:
- 零值规则:
int为 0、float64为 0、string为""、bool为false、指针与interface为nil、slice/map/chan为nil、struct逐字段取零值。 nilslice 可直接len、range、append;nilmap 可以读(返回零值),但写入会 panic(assignment to entry in nil map)。:=只在函数内可用,且要求左侧至少有一个新变量;var可用于包级。- 常量是编译期值,
iota在每个const块内从 0 自增;无类型常量在赋值时才确定类型,所以const x = 1能同时赋给int8和float64。
最小可运行示例:
package main
import "fmt"
type Config struct {
Name string
Timeout int
Tags []string
Extra map[string]string
}
func main() {
var cfg Config // 全部字段取零值
fmt.Printf("%q %d %v %v\n", cfg.Name, cfg.Timeout, cfg.Tags, cfg.Extra) // "" 0 [] map[]
var s []int // nil slice
s = append(s, 1) // append 对 nil slice 合法,返回新 slice
fmt.Println(len(s), cap(s)) // 1 1
var m map[string]int // nil map
fmt.Println(m["missing"]) // 0,读 nil map 不 panic
// m["k"] = 1 // 取消注释即 panic: assignment to entry in nil map
m = make(map[string]int, 8)
m["k"] = 1
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
panic: assignment to entry in nil map |
声明了 map 没 make |
用 make(map[K]V) 或字面量 map[K]V{} 初始化 |
declared and not used |
:= 声明后未使用,Go 视为编译错误 |
删除或改为 _ = x(仅调试用) |
| 配置结构体字段全为默认值,无法区分"未设置"与"设置为 0" | 零值语义无法表达"缺失" | 用指针字段 *int 或 sql.NullInt64 表达可选 |
const 参与运算后类型不符 |
无类型常量与已确定类型的变量混算 | 显式转换 float64(n),或把常量声明为有类型 |
面试考法:经典问法是"var s []int 和 s := make([]int, 0) 有什么区别"。要答出:前者是 nil slice(指针为 nil、len 0、cap 0),后者指向一个非 nil 的零长度数组;两者 len 都是 0、都能 append,但 json.Marshal 的结果分别是 null 与 [],这是接口返回体不一致的常见来源。追问会到"结构体零值能不能直接当业务上的'空'"。
5.3 基本类型、字符串与 rune
为什么需要它:Go 的 string 是只读字节序列,不是 UTF-16 或"字符数组"。中文、emoji 的截取与长度统计一旦按字节算,就会得到乱码或错误的字数。
核心机制:
- 整型有明确宽度:
int8/16/32/64、uint8/16/32/64,以及平台相关的int/uint(64 位平台为 8 字节),byte是uint8的别名,rune是int32的别名。 string底层是"数据指针 + 长度"的双字段结构,不可变:任何"修改"都会产生新字符串。len(s)返回字节数;utf8.RuneCountInString(s)返回字符(rune)数;for i, r := range s按 rune 迭代,i是字节下标。[]byte(s)与string(b)都是复制转换,大字符串反复转换是常见性能坑;strings.Builder适合循环拼接。- 溢出是静默的:
int8(127) + 1得到 -128,没有异常。
最小可运行示例:
package main
import (
"fmt"
"strings"
"unicode/utf8"
)
func main() {
s := "Go语言"
fmt.Println(len(s)) // 8:4 个 ASCII 字节 + 4 个 UTF-8 字节
fmt.Println(utf8.RuneCountInString(s)) // 4
// 按字节截取会截断多字节字符
fmt.Printf("%q\n", s[:3]) // "Go\xe8":出现半个汉字
// 按 rune 截取需要先转换,代价是一次复制
rs := []rune(s)
fmt.Printf("%q\n", string(rs[:3])) // "Go语"
// 循环拼接:不要用 s += x
var b strings.Builder
b.Grow(len(s) * 2) // 预分配,减少扩容
for i := 0; i < 3; i++ {
b.WriteString(s)
}
fmt.Println(b.String())
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
截取后出现 \xe8 之类的残字节 |
用字节下标截取多字节字符 | 转 []rune 后截取,或按 utf8.DecodeRuneInString 走 |
| 统计"字数"偏大 | 用 len(s) 把字节当字符 |
用 utf8.RuneCountInString |
循环里 s += part 后内存暴涨 |
每次拼接都复制整个字符串 | 用 strings.Builder 或 strings.Join |
int8 计数出现负数 |
溢出静默回绕 | 用更大宽度类型,或加显式边界判断 |
面试考法:常见问法是"Go 的 string 为什么不可变,不可变带来什么代价",以及"[]byte 与 string 互转的代价在哪里"。答到"不可变让 string 可安全共享、可做 map 键、无需拷贝即可传参;代价是每次修改都要新分配,所以高频拼接要用 Builder"。追问常给一段"截取中文乱码"的代码让你指出问题。
5.4 指针、struct 与方法
为什么需要它:Go 的方法集决定了接口实现,而值接收者与指针接收者的选择,直接决定"改了字段调用方能不能看到"。这是 Go 面试出现频率最高的语法细节之一。
核心机制:
&T{}取地址,*p解引用;Go 没有指针运算,unsafe.Pointer才能做地址运算。- 值接收者
func (s S) M()收到的是副本,方法内改字段不影响调用方;指针接收者func (s *S) M()改的是原对象。 - 方法集规则:
*S的方法集包含值接收者与指针接收者方法;S的方法集只包含值接收者方法。所以把S值赋给需要指针方法的接口会编译失败(cannot use s (type S) as type I ...)。 - 结构体内存按字段对齐,字段顺序影响
unsafe.Sizeof;把大字段放前、小字段归并可减少填充。 - 嵌入字段(匿名组合)会把方法"提升"到外层,形成类似继承的效果,但不是继承。
最小可运行示例:
package main
import "fmt"
type Counter struct {
name string
count int64
flag bool // 与 int64 之间会产生填充字节
}
// Add 用指针接收者:必须修改原对象
func (c *Counter) Add(n int64) { c.count += n }
// Snapshot 用值接收者:只读,避免意外修改
func (c Counter) Snapshot() int64 { return c.count }
type Adder interface{ Add(int64) }
func main() {
c := Counter{name: "req"}
c.Add(3)
fmt.Println(c.Snapshot()) // 3
var a Adder = &c // 指针实现了 Add,可以赋给接口
// var a2 Adder = c // 编译错误:值的方法集不含 Add
a.Add(1)
fmt.Println(c.count) // 4
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| 方法里改了字段,外面读还是旧值 | 用了值接收者 | 改指针接收者 func (c *Counter) |
cannot use c (type Counter) as type Adder |
值的方法集缺少指针方法 | 传 &c,或把方法改为值接收者 |
range 中取元素地址,最后全是同一个值 |
循环变量复用(Go 1.22 之前) | Go 1.22 起每次迭代新变量;旧版本显式 v := v |
结构体 Sizeof 比字段之和更大 |
字段对齐填充 | 调整字段顺序,或用 unsafe.Offsetof 观察 |
面试考法:"值接收者和指针接收者怎么选"几乎必问。标准回答是"需要修改接收者、接收者是包含 sync.Mutex 等不可复制字段的类型、或对象较大避免复制时用指针;只读的小对象用值接收者"。追问会问"为什么 sync.Mutex 必须用指针接收者",答案要落到"复制锁会导致锁失效、go vet 会直接报 passes lock by value"。
5.5 slice 与底层数组
为什么需要它:slice 是 Go 里最常用的容器,也是线上"数据被莫名改写""内存不释放"两类问题的根源。它的三个字段(指向底层数组的指针、长度 len、容量 cap)必须能画出来。
核心机制:
s[i:j]生成的子 slice 与原 slice 共享底层数组,cap从i算到数组末尾。append时若len+新增 <= cap,原地写并返回同一底层数组;超出cap则分配新数组(容量按策略放大)并复制。- 扩容策略(Go 1.18 起):所需容量超过旧容量两倍时直接用所需值;旧容量小于 256 时按 2 倍增长;否则按约 1.25 倍增长,最后按内存分配器的 size class 向上取整。因此
cap的具体数值不必背,但"何时会换数组"必须清楚。 - 三索引切片
s[i:j:k]可限制新 slice 的 cap,防止append写到"别人的区域"。 copy(dst, src)只复制min(len(dst), len(src))个元素,不做扩容。
最小可运行示例:
package main
import "fmt"
func main() {
base := make([]int, 3, 8) // len 3, cap 8
base[0], base[1], base[2] = 1, 2, 3
sub := base[1:2] // 共享底层数组,len 1, cap 7
fmt.Println(len(sub), cap(sub)) // 1 7
sub = append(sub, 99) // 容量足够:原地写,覆盖 base[2]
fmt.Println(base) // [1 2 99]:base 被意外改写
// 限制 cap,避免 append 越界写入原数组
safe := base[1:2:2] // len 1, cap 1
safe = append(safe, 100) // 容量不足:分配新数组
fmt.Println(base) // [1 2 99]:base 不再被影响
// 全量复制,切断共享
dst := make([]int, len(base), len(base))
copy(dst, base)
dst[0] = 42
fmt.Println(base[0], dst[0]) // 1 42
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| 修改子 slice 后原 slice 数据变了 | s[i:j] 共享底层数组 |
需要独立时用 copy 或 append([]T(nil), s...) |
| 小 slice 持有大数组导致内存不释放 | 子 slice 仍引用整块底层数组 | 复制出需要的小段,或用三索引切片限制 cap |
append 后原 slice 看不到新元素 |
扩容换了新数组,返回的是新 slice | 必须接收 append 的返回值 |
copy 后目标长度没变 |
copy 不改变 len |
目标先用 make([]T, n) 指定长度 |
面试考法:高频题是"slice 与数组的区别""append 什么时候会重新分配""为什么 append 要接收返回值"。要能画出三字段结构并说明扩容后的新旧 slice 关系。进阶追问:"s := make([]int, 10); s = append(s, 1) 之后 len 和 cap 各是多少",答案是 len=11、cap 至少 20(旧 cap 10 小于 256,翻倍)。更狠的追问是"两个 goroutine 各自 append 同一个 slice 会怎样",答案是数据竞争,因为底层数组共享。
5.6 map 的实现与并发限制
为什么需要它:map 是缓存、索引、去重的默认结构,但它不是线程安全的,写错就是进程级崩溃(fatal error,recover 抓不住)。
核心机制:
- 底层是哈希桶(bucket)数组:每个桶存 8 个键值对,键的哈希值低 8 位决定桶号,高 8 位存在桶内用于快速比对(tophash)。
- 触发扩容的负载因子约为 6.5(平均每个桶 6.5 个元素),扩容分等量扩容(溢出桶过多)与翻倍扩容两种,采用渐进式搬迁:每次读写在
oldbuckets里顺手搬一两个桶。 - 键必须是可比较类型:slice、map、func 不能做键;结构体做键要求所有字段可比较。
- 遍历顺序随机(由随机起点决定),不能依赖顺序;
for range中删除元素是安全的,新增可能触发扩容行为不确定。 - 并发读写会被运行时检测到:
fatal error: concurrent map read and map write或concurrent map writes,直接 abort 进程。
最小可运行示例:
package main
import (
"fmt"
"sync"
)
func main() {
// 单 goroutine:读不存在的键返回零值
m := make(map[string]int, 16)
m["a"] = 1
fmt.Println(m["b"], m["a"]) // 0 1
if v, ok := m["b"]; ok {
fmt.Println(v)
}
// 并发场景必须自己加锁或用 sync.Map
var (
mu sync.RWMutex
sm = map[string]int{}
)
var wg sync.WaitGroup
for i := 0; i < 8; i++ {
wg.Add(1)
go func(i int) {
defer wg.Done()
mu.Lock()
sm[fmt.Sprint(i)] = i // 加锁写
mu.Unlock()
}(i)
}
wg.Wait()
fmt.Println(len(sm))
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
fatal error: concurrent map writes |
多 goroutine 无锁写同一 map | 加 sync.RWMutex,或改 sync.Map,recover 无效 |
hash of unhashable type []int |
用 slice 做键 | 用 fmt.Sprint / 自定义可比较结构体 / 序列化为字符串 |
| 依赖遍历顺序做业务逻辑 | 遍历起点随机 | 需要顺序时另存有序 key 列表并排序 |
| map 内存只增不降 | 删除键不会缩容 | 大量删除后重建 map,或控制单次生命周期 |
面试考法:"map 为什么不能并发写""sync.Map 适合什么场景""map 的扩容过程"。答题要点:并发写触发运行时检测是因为哈希桶没有做锁保护,官方选择快速失败而不是加锁,避免读路径变慢;sync.Map 用读写分离(read 原子快照 + dirty map)优化"读多写少、键集合相对稳定"的场景,普通计数场景用 RWMutex 更合适。
5.7 控制流、函数与 defer
为什么需要它:defer 是 Go 资源管理的唯一常规手段,但它的求值时机与命名返回值的配合常被误解;recover 的作用边界也常被夸大。
核心机制:
for是唯一的循环语句,三种形态:for {}、for cond {}、for init; cond; post {};没有while。switch默认不穿透,多个条件可写case 1, 2:;switch x := v.(type)是类型分支。defer f(args)的参数在注册时求值,函数体在返回前执行,多个 defer 按 LIFO 顺序。- 命名返回值与
defer配合:defer 中的函数可以修改命名返回值(闭包捕获),常用于错误兜底。 recover只在defer直接调用的函数中有效,且只能捕获同一 goroutine 的 panic;子 goroutine panic 会让整个进程退出。
最小可运行示例:
package main
import (
"errors"
"fmt"
"os"
)
// ReadAll 演示 defer 关闭句柄 + 命名返回值改造错误
func ReadAll(path string) (data []byte, err error) {
f, err := os.Open(path)
if err != nil {
return nil, fmt.Errorf("open %s: %w", path, err)
}
defer func() {
if cerr := f.Close(); cerr != nil && err == nil {
err = cerr // 关闭失败且无其他错误时,把关闭错误返回出去
}
}()
return os.ReadFile(path)
}
func safeCall(fn func()) (err error) {
defer func() {
if r := recover(); r != nil {
err = fmt.Errorf("panic recovered: %v", r)
}
}()
fn()
return nil
}
func main() {
_, err := ReadAll("not-exist.txt")
fmt.Println(errors.Is(err, os.ErrNotExist)) // true:%w 保留了错误链
err2 := safeCall(func() { panic("boom") })
fmt.Println(err2) // panic recovered: boom
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
defer 里打印的变量值是旧值 |
参数在注册时求值 | 用闭包 defer func(){ ... }() 延迟读取 |
recover 拿不到 panic |
不在 defer 直接调用链里,或 panic 发生在别的 goroutine | defer func(){ if r:=recover(); ... }() 放在同一 goroutine |
循环里 defer f.Close() 句柄耗尽 |
defer 到函数返回才执行,循环内堆积 | 把循环体抽成函数,或手动关闭 |
errors.Is 判断失败 |
用 %v 包装,错误链断了 |
用 %w 包装 |
面试考法:"defer 的执行顺序与求值时机""recover 能不能捕获子 goroutine 的 panic""为什么 defer f.Close() 写在 if err != nil 之后"。答题要点要具体到"参数注册时求值、LIFO、命名返回值可被改写、recover 只在同 goroutine 有效"。
六、分层练习
三档练习逐档升级,上一档没做完不要跳。每档都给出验收标准与预计耗时,做完写进自己的工程目录。
6.1 复现型(照着做,目标是"跑通 + 能解释")
| 练习 | 要求 | 验收标准 | 预计耗时 |
|---|---|---|---|
| 搭建多包工程 | 建立 cmd/、store/、internal/ 三层,实现内存键值存储 |
go build ./...、go vet ./... 无输出;外部模块导入 internal 包失败 |
1.5 小时 |
| slice 共享实验 | 复现"子 slice append 覆盖原数组",再分别用三索引切片与 copy 修复 |
能画出两次操作前后 len/cap 与底层数组关系 | 1 小时 |
| 中文字符串处理 | 统计一句中文的字节数与字数,按字符截取前 N 个 | 截取结果无乱码;len 与 RuneCountInString 差异能解释 |
1 小时 |
| map 并发崩溃复现 | 起 10 个 goroutine 无锁写同一 map,跑 go run -race 与普通运行 |
能说清普通运行的 fatal error 与 -race 报告的差别 |
1 小时 |
| defer 与错误链 | 用 %w 包装打开文件错误,用 errors.Is 判断 |
errors.Is(err, os.ErrNotExist) 为 true |
0.5 小时 |
6.2 改造型(给出现成代码,改出正确行为)
| 练习 | 要求 | 验收标准 | 预计耗时 |
|---|---|---|---|
| 修一个"改了不生效"的方法 | 给定值接收者的 Add 方法,改成指针接收者并让接口实现成立 |
接口赋值编译通过,字段修改对外可见 | 1 小时 |
| 消除大数组驻留 | 给定从大 buffer 切出的子 slice,改成复制小段 | 用 runtime.ReadMemStats 前后对比,堆占用下降 |
2 小时 |
| 替换字符串拼接 | 把循环 += 改成 strings.Builder,预分配容量 |
基准测试 go test -bench 分配次数(allocs/op)明显下降 |
1 小时 |
| 加锁改造并发 map | 把裸 map 改成 sync.RWMutex 保护,读写路径分离 |
-race 无报告,并发读写结果正确 |
1.5 小时 |
| 引入配置校验 | 用指针字段区分"未设置"与"设置为零值" | 缺字段时返回明确错误而非静默取默认值 | 2 小时 |
6.3 设计型(自己定方案,目标是"能交付、能讲清取舍")
| 练习 | 要求 | 验收标准 | 预计耗时 |
|---|---|---|---|
| 文件处理命令行工具 | 读取 CSV,按字段聚合,支持 -top N、-out 参数 |
处理 100 万行不 OOM;错误信息带文件名与行号;有 flag 帮助输出 |
6 小时 |
| 内存索引结构设计 | 为"按前缀检索"的键值集合设计结构,说明为何不用裸 map 顺序扫描 | 给出复杂度分析与内存估算;用基准测试证明优于线性扫描 | 4 小时 |
| 内存缓存淘汰策略 | 实现 LRU 或 LFU,要求并发安全、容量可配 | -race 干净;命中率与淘汰行为有测试用例覆盖 |
5 小时 |
| 文本清洗流水线 | 把"读取→按 rune 清洗→聚合→输出"做成可组合的函数链 | 每步可单测;处理 5 万条中文文本无乱码 | 4 小时 |
七、排障表
| 现象 | 可能原因 | 排查步骤 | 解决办法 |
|---|---|---|---|
编译报 undefined: xxx |
包未导入、标识符未导出、拼写错误 | go vet ./... 看包列表;确认首字母大写 |
补 import 或改为导出名 |
declared and not used |
变量声明后未使用 | 看报错行号 | 删除变量或改为 _ |
| 切片数据被"莫名"改写 | 子 slice 与父 slice 共享底层数组 | 打印两个 slice 的 len/cap 与 &s[0] |
用 copy 或三索引切片切断共享 |
进程直接退出并打印 fatal error: concurrent map writes |
无锁并发写 map | 用 -race 复现,定位到写 map 的调用栈 |
加锁或换 sync.Map;注意 recover 无效 |
| 内存持续上涨不下降 | 小 slice 引用大底层数组;map 删除不缩容 | 用 pprof 看 heap inuse;检查是否有长生命周期的子 slice |
复制需要的小段;定期重建 map |
| 中文输出乱码或截断 | 按字节截取;终端编码非 UTF-8 | fmt.Printf("%q") 看实际字节 |
用 []rune 处理;确认终端与文件均为 UTF-8 |
cannot use x (type T) as type I |
接口要求指针方法,传了值 | 看接口方法集与实现方法接收者 | 传 &x 或改方法接收者 |
defer 里拿到旧值 |
defer 参数在注册时求值 | 在 defer 内打印变量 | 改为闭包形式延迟求值 |
八、出口条件
全部勾选后再进入 阶段 2 类型系统、错误处理与工程约定。
- [ ] 能独立搭出
go.mod+ 多包 + 单测的工程,go build ./...、go vet ./...、go test ./...全部通过 - [ ] 能画出 slice 的三字段结构,并解释
append在容量足够与不足时分别发生了什么 - [ ] 能说清值接收者与指针接收者对方法集的影响,遇到接口赋值失败能一次定位
- [ ] 能解释
len(s)与字符数的差异,处理中文不出现乱码 - [ ] 能说清 map 的桶结构、扩容触发条件,以及并发写为什么是
fatal error - [ ] 能用
defer+ 命名返回值把关闭错误合并进返回值,能用%w保留错误链 - [ ] 排障表里的八个现象,随机抽三个能在 5 分钟内给出排查路径
自测题(先自己想,再看要点):
var s []int与s := []int{}的区别是什么?序列化成 JSON 分别得到什么?- 要点:nil slice 与空 slice;
null与[];两者len都为 0、都可append。
- 要点:nil slice 与空 slice;
s := make([]int, 3, 5),执行s = append(s, 1, 2, 3)后len与cap是多少?底层数组换了吗?- 要点:
len=6超过cap=5,必须换数组;新 cap 按扩容策略取 10(旧 cap 5 < 256,翻倍)。
- 要点:
- 为什么把
Counter值赋给要求Add(int64)的接口会编译失败?怎么修?- 要点:值的方法集不含指针接收者方法;传
&c或把方法改为值接收者(后者改不了原对象)。
- 要点:值的方法集不含指针接收者方法;传
fatal error: concurrent map writes能否用recover兜住?为什么?- 要点:不能。它是运行时
throw而不是 panic,直接 abort,进程不会进入 defer。
- 要点:不能。它是运行时
defer中修改命名返回值为什么能生效?与普通局部变量有何不同?- 要点:命名返回值是函数级别的变量,defer 闭包捕获的是它;普通返回值在 return 时已拷贝。
- 一个从 10 MB buffer 切出的 100 字节子 slice 会带来什么问题?两种修法各有什么代价?
- 要点:整个 10 MB 无法回收;复制小段有一次拷贝成本,三索引切片只限制 cap 不释放旧数组。
strings.Builder与bytes.Buffer在纯拼接场景的差别是什么?- 要点:Builder 不允许复制(含
noCopy),写入更省;Buffer 支持读写与Bytes()零拷贝取结果,但可被复制导致数据共享问题。
- 要点:Builder 不允许复制(含