罗罗编程学习记录
本页内容 展开查看

05.3 阶段 2 类型系统、错误处理与工程约定

所属:全栈开发面试题库 / 学习路径 / 05 Go 全栈

本页目录

一、阶段定位

阶段 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 的表驱动测试

自测题:

  1. Go 的接口为什么是"隐式实现"?这对接口设计有什么影响?
    • 要点:不需要 implements 声明,使用方定义接口,实现方无需 import 使用方;因此接口应该小、由使用方定义。
  2. 一个函数返回 var s *MemStore = nil,外层 if err == nil 不成立,为什么?
    • 要点:接口值是 type + data 二元组,包装 *MemStore(nil) 后 type 非 nil;函数内判断后直接返回接口 nil。
  3. errors.Is 与 errors.As 的区别?什么时候用 %w?
    • 要点:Is 判断相等(哨兵错误),As 提取类型;%w 保留错误链,%v 断链。
  4. comparable 约束是什么意思?为什么 slice 不能做 map 键?
    • 要点:表示可做 ==;slice/map/func 不可比较,因为它们是引用类型。
  5. 为什么业务代码不该用反射?框架代码(如 encoding/json)为什么可以?
    • 要点:反射慢、失去编译器检查;框架代码一次写好、到处用,性能摊薄。
  6. cmd/internal/pkg 三个目录的职责是什么?
    • 要点:cmd 是入口,internal 是业务(外部不可见),pkg 是公共库(可选)。