05.3 阶段 2 类型系统、错误处理与工程约定
本页目录
一、阶段定位
阶段 1(05.2)解决的是"数据怎么表示":变量、零值、slice、map、指针、struct、defer。本阶段开始解决"模块之间怎么协作":用什么抽象边界(接口)、错误怎么跨层传递(错误包装)、通用逻辑怎么写(泛型)、项目目录怎么分层、依赖怎么注入。这四件事决定了你写出来的是"能跑的脚本"还是"能维护的服务"。
与前后阶段的衔接:
- 往上接阶段 1:本阶段的接口建立在方法集与值/指针接收者之上,如果对"为什么
S值不能赋给要求指针方法的接口"还不熟,先回 05.2 的 5.4 节 复习。 - 往下接阶段 3(05.4):并发阶段会大量用到接口抽象(
io.Reader、context.Context)与错误包装(下游超时错误要能被上层errors.Is判断),本阶段不打好错误链基础,并发阶段的超时取消会变成一团乱麻。
原提纲里的"卡点"展开成可判断的现象依据,满足任意一条就算卡在本阶段:
- 接口过度设计:上来就给每个实体都写
UserRepository、UserService、UserHandler三层接口,但只有一个实现,接口与实现一一对应,等于把简单的事情复杂化,新增字段要改三个文件。 - 把泛型当万能解法:看到
map[string]any就想"这里应该用泛型重构成Map[K,V]",结果约束写不出来、可读性反而下降。 - 在业务代码里滥用反射与
unsafe:为了"通用 JSON 解析"自己写reflect代码,比encoding/json慢 10 倍还容易出 bug。 - 错误处理混乱:函数返回
error,上层只fmt.Println(err)不包装,最终线上看到一行sql: no rows in result set不知道是哪一步查的。
二、阶段目标与投入
| 能力目标(可验证的行为) | 验证方式 |
|---|---|
能设计小而正交的接口(如 Store、Clock),业务代码依赖接口而非具体实现 |
写一个内存版 Store 与一个 Redis 版 Store,业务代码不修改即可切换 |
能用 %w 包装错误,上层用 errors.Is / errors.As 判断根因 |
复现"底层 sql.ErrNoRows 在三层包装后仍能被 errors.Is(err, sql.ErrNoRows) 命中" |
能写一个带类型参数与约束的泛型函数(如 Map[S,T any]) |
编译通过,能对 []int 与 []string 复用同一函数 |
能说明反射与 unsafe 不该用在什么地方 |
被问到"为什么业务代码不该用 unsafe.Pointer"时能给出三个反例 |
| 能按"cmd / internal / pkg / api"分层组织一个小型服务工程 | go build ./... 通过,业务逻辑与 HTTP 入口在不同目录 |
| 能写出表驱动单元测试覆盖主要分支 | 一个函数有 5+ 条 case 的 tests := []struct{...} |
建议学时:
- 全职(每天 4–6 小时):2 周,约 50–60 小时。读官方 Effective Go 与 Go 规范约 15 小时,写代码与重构约 35 小时。
- 在职(每天 2 小时、周末补 4 小时):4–5 周,约 60 小时。接口与错误处理各占一周,泛型与工程约定各占半周。
学时分配建议:接口与类型断言 25%、错误处理 20%、泛型 15%、反射与 unsafe 边界 5%、项目分层与依赖注入 20%、表驱动测试 15%。
三、先修自检
| 先修项 | 合格标准 | 不合格时回到 |
|---|---|---|
| 值/指针接收者 | 能说清什么时候用值、什么时候用指针,知道方法集规则 | 05.2 的 5.4 节 |
| struct 与方法 | 能写一个带方法的 struct 并在 main 中调用 | 05.2 的 5.4 节 |
| defer 与错误 | 能写出"打开文件失败也要关闭已打开句柄"的函数 | 05.2 的 5.7 节 |
| 包与模块 | 能 go mod init、能建多包工程 |
05.2 的 5.1 节 |
| slice 与 map | 能画出 slice 三字段、知道 map 不能并发写 | 05.2 的 5.5 / 5.6 节 |
经验判断:有 Java 经验的人容易把接口当"抽象类"用,给每个实体都抽一层;有 Python 经验的人容易到处用 any 逃避类型;有 C++ 经验的人容易把泛型当模板。这三类偏差都要在练习里主动纠正。
四、知识地图
| 模块 | 知识点 | 掌握程度 | 对应题库章节 |
|---|---|---|---|
| 接口 | 隐式实现、方法集、小接口、接口组合 | 能讲清原理 | 04.3 Go |
| 类型断言 | x.(T)、comma-ok、x.(type) |
会用 | 04.3 Go |
| 错误处理 | error 接口、%w、errors.Is/As、自定义错误类型 |
能讲清原理 | 04.3 Go |
| 泛型 | 类型参数、any 约束、comparable、类型实例化 |
会用 | 04.3 Go |
| 反射与 unsafe | reflect 能力边界、unsafe.Pointer 风险 |
了解 | 04.3 Go |
| 工程分层 | cmd/internal/pkg 布局、依赖方向、配置加载 |
会用 | 06.1 通用后端工程 |
| 依赖注入 | 构造函数注入、接口替换、wire 等代码生成 |
会用 | 06.1 通用后端工程 |
| 测试 | 表驱动、t.Run、子测试、testify 取舍 |
会用 | 06.1 通用后端工程 |
进度管理建议:接口与错误处理是面试高频,必须到"能讲清原理";反射与 unsafe 只要求"知道什么时候不该用",不要花时间学写反射代码。
五、分模块精讲
5.1 接口与隐式实现
为什么需要它:Go 的接口是隐式实现,不需要 implements 声明。这让你可以在使用方定义接口,而不是在实现方——标准库的 io.Writer 只有一个 Write([]byte) (int, error),任何有这个方法的类型都自动实现了它,不需要提前知道。
核心机制:
- 接口是一组方法签名的集合;一个类型只要实现接口的所有方法,就自动实现了该接口。
- 接口值内部是"类型指针 + 数据指针"的二元组;这就是为什么
var w io.Writer = (*os.File)(nil)不等于nil——类型指针非 nil,只是数据指针为 nil。 - 接口设计遵循"小接口"原则:
io.Reader、io.Writer、io.Closer都是 1 个方法;大接口通过组合小接口得到(io.ReadWriter= Reader + Writer)。 - 接受接口、返回具体类型(Accept Interfaces, Return Structs)是 Go 的常见建议:函数参数尽量用接口以便替换,返回值尽量用具体类型避免不必要的接口开销。
any是空接口(Go 1.18 起的别名),表示任意类型;滥用any等于放弃类型检查。
最小可运行示例:
package main
import (
"errors"
"fmt"
)
// Store 是一个小接口:只有两个方法,由使用方定义
type Store interface {
Get(key string) (string, error)
Set(key, val string) error
}
// MemStore 是内存实现
type MemStore struct {
data map[string]string
}
func NewMemStore() *MemStore {
return &MemStore{data: map[string]string{}}
}
func (m *MemStore) Get(key string) (string, error) {
if v, ok := m.data[key]; ok {
return v, nil
}
return "", errors.New("key not found: " + key)
}
func (m *MemStore) Set(key, val string) error {
m.data[key] = val
return nil
}
// biz 依赖 Store 接口,不依赖具体实现
func biz(s Store, key string) (string, error) {
return s.Get(key)
}
func main() {
var s Store = NewMemStore() // MemStore 没声明实现 Store,自动成立
_ = s.Set("name", "ann")
v, err := biz(s, "name")
fmt.Println(v, err) // ann <nil>
// 接口 nil 与具体类型 nil 的区别
var s2 Store = (*MemStore)(nil)
fmt.Println(s2 == nil) // false:类型指针非 nil
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
函数返回 var s *Store = nil 后上层 if err == nil 不成立 |
接口值被具体类型 nil 包装后不等于接口 nil | 返回时不要包一层 nil 指针;或返回具体类型 (*Store)(nil),在函数内判断后再返回 nil |
给每个实体都写 XxxRepository 接口但只有一个实现 |
过度设计 | 只有两个以上实现(或需要 mock)时才抽接口;否则直接用 struct |
cannot use x (type T) as type I |
值的方法集缺少指针方法 | 传 &x 或改方法接收者(见 05.2) |
| 接口里方法太多(5+ 个) | 违反小接口原则 | 拆成多个小接口,按需组合 |
面试考法:"Go 的接口和 Java 的接口有什么区别""为什么说接口是隐式实现""接口 nil 为什么不等于 nil"。要答到:隐式实现让使用方定义接口,实现方不需要 import 使用方;接口值是 type + data 二元组,包装了具体类型 nil 后 type 仍非 nil。
5.2 类型断言与类型分支
为什么需要它:拿到 any 类型的值后,必须用类型断言才能取到底层类型。这是写反序列化、中间件、通用工具函数时绕不开的。
核心机制:
x.(T)断言x的底层类型是T;断言失败会 panic。- comma-ok 形式
v, ok := x.(T):失败时ok=false、v取零值,不 panic。 switch x := v.(type) { case int: ... case string: ... }是类型分支,编译器自动判断每个 case 的类型。- 断言接口类型时,
x.(io.Reader)是判断"底层类型是否实现了 io.Reader",而不是"x 是否等于 io.Reader 类型"。
最小可运行示例:
package main
import "fmt"
func describe(v any) string {
switch x := v.(type) {
case nil:
return "nil"
case int:
return fmt.Sprintf("int: %d", x)
case string:
return fmt.Sprintf("string: len=%d", len(x))
case []int:
return fmt.Sprintf("[]int: len=%d", len(x))
default:
return fmt.Sprintf("unknown: %T", x)
}
}
func main() {
fmt.Println(describe(42)) // int: 42
fmt.Println(describe("hello")) // string: len=5
fmt.Println(describe([]int{1})) // []int: len=1
fmt.Println(describe(3.14)) // unknown: float64
// comma-ok 形式
var a any = "abc"
if s, ok := a.(string); ok {
fmt.Println(s) // abc
}
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
panic: interface conversion: interface {} is int, not string |
用 x.(T) 直接断言且类型不匹配 |
改用 comma-ok v, ok := x.(T) |
| 类型断言到接口类型但没生效 | 底层类型没实现该接口 | 用 x.(io.Reader) 时,先确认底层类型有 Read 方法 |
大量 switch v.(type) 让函数变臃肿 |
用 any 逃避类型设计 | 改用泛型函数或接口方法 |
面试考法:"x.(T) 与 comma-ok 形式的区别""类型断言能断言到非接口类型吗"。要点:comma-ok 不 panic;类型断言可以断言任意具体类型或接口类型,断言到接口是在判断"底层类型是否实现了该接口"。
5.3 错误处理与错误包装
为什么需要它:Go 的错误是显式返回值,不是异常。一个 HTTP 请求经过 handler → service → repository → sql,错误要跨层传递。如果不包装,上层只能看到 sql: no rows in result set,不知道是哪一步、查的哪个表。
核心机制:
error是内建接口:type error interface { Error() string }。任何实现该接口的类型都是错误。fmt.Errorf("...: %w", err)用%w包装底层错误,形成错误链;用%v包装则链断裂。errors.Is(err, target)沿错误链查找是否有等于target的错误(用于判断os.ErrNotExist、sql.ErrNoRows等哨兵错误)。errors.As(err, &target)沿错误链查找是否有能赋值给target的错误类型(用于提取自定义错误的字段,如*net.OpError、*MyError)。- 自定义错误类型应实现
Error() string并携带业务字段;通过Unwrap() error方法支持错误链。
最小可运行示例:
package main
import (
"database/sql"
"errors"
"fmt"
)
// 自定义业务错误:携带 code
type BizError struct {
Code int
Msg string
Err error
}
func (e *BizError) Error() string { return fmt.Sprintf("[%d] %s: %v", e.Code, e.Msg, e.Err) }
func (e *BizError) Unwrap() error { return e.Err }
func getUser(id string) (string, error) {
// 模拟底层 sql 错误
return "", fmt.Errorf("query user %s: %w", id, sql.ErrNoRows)
}
func service() error {
u, err := getUser("100")
if err != nil {
return &BizError{Code: 404, Msg: "user not found", Err: err}
}
return nil
}
func main() {
err := service()
fmt.Println(err) // [404] user not found: query user 100: sql: no rows in result set
// 沿错误链判断是否是 sql.ErrNoRows
if errors.Is(err, sql.ErrNoRows) {
fmt.Println("root cause: no rows") // 命中
}
// 提取 BizError
var be *BizError
if errors.As(err, &be) {
fmt.Println("code =", be.Code) // 404
}
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
errors.Is(err, sql.ErrNoRows) 始终 false |
中间层用 %v 包装,错误链断了 |
改 %w 包装 |
| 错误信息重复且冗长 | 每层都 fmt.Errorf("...: %v", err) |
顶层只加上下文,底层保留原始错误;用 %w 不重复内容 |
errors.As 失败 |
target 不是指针,或类型不匹配 | 传 var be *BizError; errors.As(err, &be)(注意双指针) |
| panic 被上层 recover 后丢失了栈 | 直接把 r 当 error 用 |
用 fmt.Errorf("panic: %v", r) 或 runtime/debug.Stack() 带栈 |
面试考法:"errors.Is 与 errors.As 的区别""为什么用 %w 而不是 %v""什么时候该用自定义错误类型"。要点:Is 判断相等(哨兵错误),As 提取类型(业务错误);%w 保留错误链;自定义错误携带业务字段(如 Code)。
5.4 泛型与类型约束
为什么需要它:没有泛型时,要写一个"通用的 Map 函数"(把 []int 映射成 []string)只能用 any 或写三份重复代码。Go 1.18 起有了类型参数,可以写真正类型安全的通用函数。
核心机制:
- 类型参数声明在函数名后:
func Map[S, T any](in []S, fn func(S) T) []T。 - 约束用接口表示:
any是最宽约束(任意类型);comparable表示可比较(支持==);~int表示底层类型是 int 的任意类型。 - 类型实例化在编译期完成:
Map([]int{1,2,3}, func(i int) string { return fmt.Sprint(i) })编译器推断 S=int、T=string。 - 泛型类型:
type Set[T comparable] map[T]struct{},使用时Set[string]。 - 什么时候不用泛型:只有一种类型、或用
any+ 接口多态已经能解决时,不要为了泛型而泛型。
最小可运行示例:
package main
import "fmt"
// Map 把 []S 映射成 []T,fn 是转换函数
func Map[S, T any](in []S, fn func(S) T) []T {
out := make([]T, len(in))
for i, v := range in {
out[i] = fn(v)
}
return out
}
// Set 用 comparable 约束:元素必须可比较才能做 map 键
type Set[T comparable] map[T]struct{}
func NewSet[T comparable](items ...T) Set[T] {
s := make(Set[T])
for _, it := range items {
s[it] = struct{}{}
}
return s
}
func (s Set[T]) Has(v T) bool {
_, ok := s[v]
return ok
}
func main() {
// 同一函数处理 []int 与 []string
ints := Map([]int{1, 2, 3}, func(i int) string { return fmt.Sprintf("N%d", i) })
fmt.Println(ints) // [N1 N2 N3]
strs := Map([]string{"a", "b"}, func(s string) int { return len(s) })
fmt.Println(strs) // [1 1]
s := NewSet("apple", "banana")
fmt.Println(s.Has("apple"), s.Has("cherry")) // true false
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
T does not satisfy comparable |
约束写 comparable 但实例用了 slice 等不可比较类型 |
换约束,或不用该类型实例化 |
泛型函数里不能用 + 操作符 |
any 约束不支持算术 |
定义数值约束(如 interface{ int | float64 | ... }) |
| 泛型代码比手写重复代码还难读 | 为了复用硬上泛型 | 先写三遍具体代码,发现模式真重复再泛型 |
面试考法:"Go 泛型和 Java 泛型的类型擦除有什么区别""comparable 约束是什么意思""什么时候不该用泛型"。要点:Go 泛型在编译期实例化,不做类型擦除(运行时知道具体类型);comparable 表示可做 ==;只有真的多类型复用、且逻辑一致时才用。
5.5 反射与 unsafe 的边界
为什么需要它:反射能在运行时检查类型(encoding/json 就是这么工作的),unsafe 能绕过类型系统直接操作内存。但这两类能力会让代码变慢、变脆、失去编译器检查。业务代码里应该把它们当最后手段。
核心机制:
reflect.TypeOf(x)与reflect.ValueOf(x)拿到运行时类型与值;reflect.Value.Field(i).SetString(...)修改字段。- 反射调用有代价:每次都要走类型检查,性能比直接调用慢 10–100 倍。
unsafe.Pointer可以把任意指针转成uintptr做地址运算,但 Go 不保证 GC 期间地址不变,使用要极小心。- 标准库用反射的场景:
encoding/json、fmt、db标签扫描——这些是"框架级"代码,一次写好、到处用。 - 业务代码不该用反射的信号:你想"动态访问字段"、想"根据配置调用不同方法"、想"绕过类型检查"。
最小可运行示例:
package main
import (
"fmt"
"reflect"
)
type User struct {
Name string `json:"name"`
Age int `json:"age"`
}
func main() {
u := User{Name: "ann", Age: 30}
// 读 tag
t := reflect.TypeOf(u)
for i := 0; i < t.NumField(); i++ {
f := t.Field(i)
fmt.Printf("field=%s json=%s\n", f.Name, f.Tag.Get("json"))
}
// 按名字读字段
v := reflect.ValueOf(u)
name := v.FieldByName("Name")
fmt.Println(name.String()) // ann
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
反射修改字段报 panic: value is not addressable |
reflect.ValueOf(u) 拿到的是副本 |
传指针 reflect.ValueOf(&u).Elem() |
| 反射代码在压测中占 CPU 大头 | 热路径里用了反射 | 改用具体类型,或代码生成(如 go generate) |
unsafe.Pointer 转换后 GC 移动对象 |
把 Pointer 转成 uintptr 存起来 | 不要存 uintptr;只在同一表达式里用 |
面试考法:"什么时候该用反射""encoding/json 怎么知道 struct 字段叫什么"。要点:框架级代码用反射一次性写好;业务代码优先用具体类型与泛型;json 通过 reflect.TypeOf 读 tag 与字段。
5.6 项目分层与目录约定
为什么需要它:Go 社区对项目布局有较强共识(cmd、internal、pkg),目的是让依赖方向单向:入口 → 业务逻辑 → 数据访问,反向依赖会让测试与替换都变难。
核心机制:
cmd/:可执行程序入口,每个子目录一个 main 包。internal/:只能被本模块内部导入的包(外部模块 import 会编译失败),放业务逻辑。pkg/:可以被外部模块导入的公共库(可选),放稳定的工具函数。api/:接口定义(protobuf、OpenAPI),与代码分离。- 依赖方向:handler → service → repository;service 不 import handler;repository 不 import service。
- 配置从环境变量或配置文件读取,不写死在代码里。
最小可运行示例:
notes/
├── go.mod
├── cmd/
│ └── notes/
│ └── main.go # 入口:加载配置、构造依赖、启动 HTTP
├── internal/
│ ├── config/
│ │ └── config.go # 配置加载
│ ├── store/
│ │ ├── store.go # Store 接口
│ │ └── mem.go # MemStore 实现
│ └── httpapi/
│ ├── handler.go # HTTP handler,依赖 store.Store
│ └── middleware.go
└── api/
└── notes.proto
// cmd/notes/main.go
package main
import (
"log"
"net/http"
"example.com/notes/internal/config"
"example.com/notes/internal/httpapi"
"example.com/notes/internal/store"
)
func main() {
cfg, err := config.Load()
if err != nil {
log.Fatal(err)
}
s := store.NewMemStore() // 构造具体实现
h := httpapi.NewHandler(s) // 依赖注入:handler 接收接口
mux := http.NewServeMux()
mux.HandleFunc("/notes", h.List)
_ = http.ListenAndServe(cfg.Addr, mux)
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
internal 包被外部模块导入失败 |
设计如此 | 把公共能力移到 pkg/,或接受只能内部使用 |
| handler 直接调 SQL | 分层破坏,业务逻辑散落 | 抽 repository,handler 只做 HTTP 适配 |
配置硬编码在 const 里 |
不利于多环境 | 用环境变量 + 默认值,或配置文件 |
面试考法:"Go 项目目录怎么组织""为什么要有 internal/""handler / service / repository 怎么分"。要点:cmd 是入口、internal 是业务、pkg 是公共;internal 防止外部依赖污染;依赖单向。
5.7 依赖注入与表驱动测试
为什么需要它:依赖注入让"替换实现"变得可能——测试时用内存版 Store,生产时用真实版 Store。表驱动测试让一组相似 case 用一个循环跑完,加 case 只加一行。
核心机制:
- 构造函数注入:
NewHandler(s store.Store)接收接口,不直接store.NewMemStore()。 - 手写注入在小项目里足够;大项目用
google/wire做代码生成,避免手工组装依赖。 - 表驱动:把 case 写成
[]struct{name string; in; want; wantErr},循环t.Run(tt.name, ...)。 - 表驱动测试自带子测试名,
go test -run TestName/case_name可单独跑。
最小可运行示例:
// internal/store/store_test.go
package store
import "testing"
func TestMemStore_Get(t *testing.T) {
s := NewMemStore()
_ = s.Set("a", "1")
tests := []struct {
name string
key string
want string
wantErr bool
}{
{"命中", "a", "1", false},
{"未命中", "missing", "", true},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got, err := s.Get(tt.key)
if (err != nil) != tt.wantErr {
t.Fatalf("err = %v, wantErr = %v", err, tt.wantErr)
}
if got != tt.want {
t.Errorf("got = %q, want = %q", got, tt.want)
}
})
}
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
测试里 time.Sleep 等待异步操作 |
没有用 channel 或 WaitGroup 同步 | 用 channel 信号或 wg.Wait() |
表驱动 case 里直接复用 tt |
循环变量在闭包里共享(Go 1.22 之前) | Go 1.22 起每次迭代新变量;旧版本 tt := tt |
| 每个测试都连真实数据库 | 没抽象出 Store 接口 | 注入内存实现,或用 testcontainers |
面试考法:"表驱动测试好在哪""依赖注入的好处""测试时怎么 mock 外部依赖"。要点:case 集中、加 case 只加一行;构造函数注入让替换实现零成本;mock 通过接口实现替换。
六、分层练习
6.1 复现型
| 练习 | 要求 | 验收标准 | 预计耗时 |
|---|---|---|---|
| 小接口实现 | 定义 Store 接口,写 MemStore 与另一个实现(如带前缀的 Store) |
业务代码不修改即可切换两个实现 | 1 小时 |
| 错误包装链 | 用 %w 包装三层错误,errors.Is 命中底层 sql.ErrNoRows |
错误链完整,Is/As 都能命中 | 1 小时 |
| 自定义错误类型 | 写一个 *BizError 带 Code 与 Msg,实现 Error 与 Unwrap |
errors.As 能提取字段 |
1 小时 |
| 泛型 Map 函数 | 写 Map[S,T any] 并对 []int 与 []string 复用 |
编译通过,结果正确 | 1 小时 |
| 表驱动测试 | 给一个"字符串反转"函数写 5 条 case | go test -v 输出每个子测试名 |
0.5 小时 |
6.2 改造型
| 练习 | 要求 | 验收标准 | 预计耗时 |
|---|---|---|---|
| 拆过度设计接口 | 给定一个只有单实现的 UserService 接口,改成直接用 struct |
删除接口后业务代码改动不超过 5 行 | 1 小时 |
| 修复错误链 | 给定一段用 %v 包装的代码,改成 %w 并补 errors.Is 测试 |
Is 命中底层错误 | 1 小时 |
| 反射改泛型 | 给定一段用反射打印 struct 字段的代码,改成泛型函数 | 性能提升(可选),可读性提升 | 2 小时 |
| 调整分层 | 把 handler 里直接写 SQL 的代码抽到 repository | 依赖方向变成 handler → repository | 2 小时 |
| 配置外置 | 把硬编码的 :8080 改成环境变量 PORT,默认 8080 |
不重启代码即可改端口 | 0.5 小时 |
6.3 设计型
| 练习 | 要求 | 验收标准 | 预计耗时 |
|---|---|---|---|
| 带接口抽象的笔记库 | 支持 Add/List/Search,依赖 Store 接口,带表驱动测试 |
内存实现可替换;测试覆盖主要分支 | 6 小时 |
| 错误码规范 | 设计一套业务错误码(404/500/400),自定义错误类型统一封装 | 上层能按 Code 返回 HTTP 状态码 | 4 小时 |
| 泛型缓存 | 实现 Cache[T any] 带过期时间与 Get/Set/Delete |
类型安全;并发安全(用 mutex) | 4 小时 |
七、排障表
| 现象 | 可能原因 | 排查步骤 | 解决办法 |
|---|---|---|---|
cannot use x (type T) as type I |
值的方法集缺少指针方法 | 看接口方法集与实现方法接收者 | 传 &x 或改接收者 |
接口值 == nil 但 if err == nil 不成立 |
返回的是 (*T)(nil) 包装进接口 |
打印 %T 与 %#v |
函数内判断后直接返回 nil,不要包类型 |
errors.Is(err, sql.ErrNoRows) 始终 false |
中间层用 %v 包装 |
看每层 Error() 输出 |
改 %w 包装 |
panic: interface conversion: ... is int, not string |
类型断言没加 comma-ok | 看 panic 行号 | 改 v, ok := x.(T) |
反射 Set 报 value is not addressable |
传了值副本 | reflect.ValueOf(u) 改成 reflect.ValueOf(&u).Elem() |
|
internal 包被外部 import 失败 |
设计如此 | 看错误信息 | 把公共能力移到 pkg/,或接受只能内部用 |
测试里 time.Sleep 经常 flaky |
异步操作没用同步原语 | 改成 channel 或 WaitGroup | |
go test 表驱动 case 都拿到同一个值 |
循环变量闭包共享(旧版本) | Go 1.22 前显式 tt := tt |
八、出口条件
全部勾选后再进入 05.4 阶段 3 并发模型。
- [ ] 能设计一个只有 2 个方法的小接口,并在两个实现间切换业务代码不修改
- [ ] 能解释接口值是 type + data 二元组,能复现并修复"接口 nil 不等于 nil"
- [ ] 能用
%w包装错误,用errors.Is判断哨兵错误、用errors.As提取自定义错误 - [ ] 能写一个带类型参数与约束的泛型函数(
Map或Set) - [ ] 能说明反射与
unsafe不该用在业务代码的三个理由 - [ ] 能按
cmd/internal/pkg分层组织一个小型服务工程,依赖方向单向 - [ ] 能写出带 5 条 case 的表驱动测试
自测题:
- Go 的接口为什么是"隐式实现"?这对接口设计有什么影响?
- 要点:不需要
implements声明,使用方定义接口,实现方无需 import 使用方;因此接口应该小、由使用方定义。
- 要点:不需要
- 一个函数返回
var s *MemStore = nil,外层if err == nil不成立,为什么?- 要点:接口值是 type + data 二元组,包装
*MemStore(nil)后 type 非 nil;函数内判断后直接返回接口 nil。
- 要点:接口值是 type + data 二元组,包装
errors.Is与errors.As的区别?什么时候用%w?- 要点:Is 判断相等(哨兵错误),As 提取类型;
%w保留错误链,%v断链。
- 要点:Is 判断相等(哨兵错误),As 提取类型;
comparable约束是什么意思?为什么 slice 不能做map键?- 要点:表示可做
==;slice/map/func 不可比较,因为它们是引用类型。
- 要点:表示可做
- 为什么业务代码不该用反射?框架代码(如
encoding/json)为什么可以?- 要点:反射慢、失去编译器检查;框架代码一次写好、到处用,性能摊薄。
cmd/internal/pkg三个目录的职责是什么?- 要点:cmd 是入口,internal 是业务(外部不可见),pkg 是公共库(可选)。