1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

 你脑子里的模型                         Go 运行时里真实发生的事
 ─────────────────                      ────────────────────────────────
 ① error 是 nil 吗？
    err == nil  ──── 返回了 nil 指针 ───► 接口 = (类型≠nil, 值=nil)
                                          └─► err != nil ❌ 陷阱

 ② 传结构体进去改
    func(v S)              ┌──────────┐
    s ────────────────────►│ S 的副本 │  改的是副本，外面纹丝不动
                           └──────────┘

 ③ 传切片进去改
    func(v []int)          ┌──────────────────────┐
    sl ───────────────────►│ 切片头副本           │
                           │ ptr ──┐ len  cap     │
                           └───────┼──────────────┘
                                   ▼
                            ┌─────────────┐
                            │ 底层数组     │ ◄── 改元素：能改到 ✅
                            └─────────────┘     append 换头：改不到 ❌

 ④ defer 在循环里
    for i { defer f(i) }   ──► 攒成一个栈，函数返回时倒着弹
                               输出 2 1 0（不是 0 1 2）

 ⑤ map 里的结构体
    m["a"].N = 99          ──► 编译错误（map 元素不可寻址）
    取→改→放回              ──► 可行但要三步 ⚠️

 ⑥ 循环里的 time.After  ──► 每轮新建一个定时器
                             ≤1.22 会泄漏；≥1.23 不可达的 Timer 可被 GC 回收 ✅

 ⑦ fmt.Errorf("%v")      ──► 错误链断开，errors.Is 永远 false ❌
    fmt.Errorf("%w")      ──► 链条保留，errors.Is 可穿透 ✅

 ⑧ "世界"                
    len(s) = 6             ──► 字节数，不是字符数
    s[0]   = 0xE4          ──► UTF-8 的首字节，不是「世」

 ⑨ 5 / 2                 ──► 2（整数除法截断），要 2.5 必须写 5.0/2

 ⑩ const ( A = iota )    ──► 每个 const 块都从 0 重新开始

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

type S struct{ N int }
func (s *S) Error() string { return "S error" }

func nilIface() error {
	var p *S
	return p            // ⚠️ 装进接口后 != nil
}

err := nilIface()
fmt.Println(err == nil, fmt.Sprintf("%T", err))

1

false *main.S

1
2
3

s := S{1}
func(v S) { v.N = 99 }(s)
fmt.Println(s.N)

1

1

1
2
3
4
5
6

sl := make([]int, 1, 3)
func(v []int) { v[0] = 99 }(sl)        // 改元素 → 生效
fmt.Println(sl[0])                      // 99

func(v []int) { v = append(v, 7) }(sl) // 改切片头 → 不生效
fmt.Println(sl, len(sl))                // [99] 1

1
2

99
[99] 1

1
2
3

for i := range 3 {
	defer fmt.Print(i, " ")
}

1

2 1 0        ← 全部在函数返回时才执行，且 LIFO

1
2
3
4
5
6
7
8
9

m := map[string]S{"a": {1}}
// m["a"].N = 99      // 🛑 编译错误：cannot assign to struct field in map

tmp := m["a"]          // 取出
tmp.N = 99             // 改副本
m["a"] = tmp           // 放回 ✅

mm := map[string]int{}
mm["k"]++              // ✅ 但 map 的值是基本类型时可以直接自增

1
2

99
1

1
2
3
4
5
6
7
8
9

start := time.Now()
ch := make(chan int, 1)
for range 3 {
	select {
	case <-ch:
	case <-time.After(30 * time.Millisecond):
	}
}
fmt.Println(time.Since(start) > 80*time.Millisecond)

1

true         ← 三个 30ms 串行等待 ≈ 90ms

1
2
3

base := errors.New("base")
fmt.Println(errors.Is(fmt.Errorf("wrap: %v", base), base))   // false ⚠️
fmt.Println(errors.Is(fmt.Errorf("wrap: %w", base), base))   // true ✅

1
2

false
true

1
2

str := "世界"
fmt.Printf("len=%d s[0]=%d first rune=%c\n", len(str), str[0], []rune(str)[0])

1

len=6 s[0]=228 first rune=世

1

fmt.Println(5/2, 5.0/2)

1

2 2.5

1
2

const ( A = iota; B )    // A=0, B=1
const ( C = iota; D )    // C=0, D=1  ⚠️ 不是 2、3

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

// 🛑 不惯用
if err != nil {
	return err
} else {
	return doSomething()
}

// ✅ 惯用：提前返回，减少嵌套（"line of sight" 原则）
if err != nil {
	return err
}
return doSomething()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// 🛑 不惯用：用 panic 表达业务失败
if user == nil {
	panic("user not found")
}

// ✅ 惯用：哨兵错误 + errors.Is
var ErrUserNotFound = errors.New("user not found")
if user == nil {
	return nil, fmt.Errorf("get user %s: %w", id, ErrUserNotFound)
}

1
2
3
4
5
6
7
8
9

// 🛑 不惯用
func GetUserById(userId string) (*User, error)   // 下划线命名 + 冗余 Get
func (this *User) Name() string                  // this/self
type IUserService interface{}                    // I 前缀

// ✅ 惯用
func (s *Store) User(ctx context.Context, id string) (*User, error)  // 接收者短名，方法名不重复包名
func (u *User) Name() string
type UserService interface{}                     // 接口用 -er 或直接名词

1
2
3
4
5
6
7
8
9

// ✅ 惯用：零值可用
type Buffer struct {
	mu   sync.Mutex
	data []byte
}
var b Buffer       // 直接可用，不需要 New ✅

// 🛑 反例：零值不可用，必须 New
type Bad struct{ m map[string]int }   // 零值时写入 panic

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

// ✅ 惯用：Options 模式（替代默认参数）
type Option func(*Server)

func WithTimeout(d time.Duration) Option { return func(s *Server) { s.timeout = d } }
func WithLogger(l *slog.Logger) Option   { return func(s *Server) { s.log = l } }

func New(opts ...Option) *Server {
	s := &Server{timeout: 30 * time.Second, log: slog.Default()}   // 默认值
	for _, o := range opts {
		o(s)
	}
	return s
}

srv := New(WithTimeout(5*time.Second))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

// ✅ 惯用：消费方定义窄接口（见 08）
type Store interface {
	Get(ctx context.Context, id string) (*User, error)
}

// ✅ 惯用：构造函数返回【具体类型】——这里是 *sqlStore，不是 *Store
type sqlStore struct{ db *sql.DB }

func NewStore(db *sql.DB) *sqlStore { return &sqlStore{db: db} }

// ✅ 惯用：接收方依赖接口
func (s *Service) SetStore(st Store) { s.store = st }

// 🛑 反例：构造函数直接返回接口
//   调用方拿不到具体类型的方法，也无法判断「是不是某个增强能力」
func NewStoreBad(db *sql.DB) Store { return &sqlStore{db: db} }

// 🛑 更糟：返回接口的指针（*Store）——Go 里几乎总是写错了
//   *Store 是「指向接口变量的指针」，既不能直接调方法，也接不住具体实现

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

// ✅ 惯用：表驱动 + 子测试
for _, tc := range tests {
	t.Run(tc.name, func(t *testing.T) { ... })
}

// ✅ 惯用：并发骨架（取消 + 上限 + 有序收集）
g, ctx := errgroup.WithContext(ctx)
g.SetLimit(10)
for i, in := range inputs {
	g.Go(func() error { results[i] = process(ctx, in); return nil })
}
err := g.Wait()