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

// 最常见：值 + 错误
func Div(a, b int) (int, error) {
	if b == 0 {
		return 0, errors.New("division by zero")
	}
	return a / b, nil
}

// 命名返回：适合需要 defer 修改返回值的场景
func Parse(s string) (n int, err error) {
	defer func() {
		if err != nil {
			n = -1          // ✅ defer 能改命名返回值
		}
	}()
	if s == "" {
		return 0, errors.New("empty")
	}
	return len(s), nil
}

1
2

r, e := namedReturn()       // 内部 return 42, fmt.Errorf("boom")
fmt.Println("namedReturn:", r, e)

1

namedReturn: -1 boom

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

func Sum(ns ...int) int {
	total := 0
	for _, n := range ns {
		total += n
	}
	return total
}

Sum()              // 0，可以一个都不传
Sum(1, 2, 3)       // 6
xs := []int{1, 2}
Sum(xs...)         // ✅ 展开切片

1
2
3
4
5
6
7
8
9

type Middleware func(http.Handler) http.Handler

func double(x int) int { return x * 2 }

var op func(int) int = double
op(21)   // 42

// 立即执行
func() { fmt.Println("IIFE") }()

1
2
3

var f1, f2 func()
fmt.Println(f1 == nil)   // ✅ true
// fmt.Println(f1 == f2) // 🛑 编译错误

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

type Value struct{ N int }

func (v Value) SetVal(n int) { v.N = n }   // 改的是副本
func (v *Value) SetPtr(n int) { v.N = n }  // 改的是原件

v := Value{N: 1}
v.SetVal(99)
fmt.Println("after SetVal:", v.N)   // 1，没变 ⚠️
v.SetPtr(99)
fmt.Println("after SetPtr:", v.N)   // 99

// map 元素不可寻址的绕法
m := map[string]Value{"a": {N: 1}}
// m["a"].SetPtr(5)   // 🛑 编译错误
tmp := m["a"]
tmp.SetPtr(5)
m["a"] = tmp           // ✅ 取出 → 改 → 放回
fmt.Println("map workaround:", m["a"].N)   // 5

// 切片元素可寻址，可以直接调
xs := []Value{{N: 1}}
xs[0].SetPtr(7)
fmt.Println("slice elem:", xs[0].N)        // 7

1
2
3
4

after SetVal: 1
after SetPtr: 99
map workaround: 5
slice elem: 7

1
2
3
4

type Big struct{ data [1 << 20]byte }   // 1 MB

func (b Big) Sum() int   { return len(b.data) }   // ⚠️ 每次调用拷贝 1 MB
func (b *Big) Sum2() int { return len(b.data) }   // ✅ 不拷贝

1
2
3
4

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

1

body done | defer 2 | defer 1 | defer 0

1
2
3
4
5

x := 1
defer fmt.Println("arg evaluated immediately:", x)   // x 在此刻被拷贝
defer func() { fmt.Println("closure sees final:", x) }()  // x 在返回时才读
x = 100
fmt.Println("x set to", x)

1
2
3

x set to 100
closure sees final: 100
arg evaluated immediately: 1

1
2
3

for _, name := range names {
	defer os.Remove(name)   // ⚠️ 参数立即求值，但函数结束才删——可能删错时刻
}

1
2
3
4
5
6
7
8

func namedReturn() (result int, err error) {
	defer func() {
		if err != nil {
			result = -1
		}
	}()
	return 42, fmt.Errorf("boom")
}

1

namedReturn: -1 boom

1
2
3
4
5
6
7
8
9

func recoverDemo() {
	defer func() {
		if r := recover(); r != nil {
			fmt.Println("recovered:", r)
		}
		fmt.Println("after recover, function returns normally")
	}()
	panic("something bad")
}

1
2

recovered: something bad
after recover, function returns normally

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// 🛑 无效：recover 直接调用
func bad() {
	if r := recover(); r != nil { }   // 永远返回 nil
}

// 🛑 无效：在 defer 调用的【另一个函数】里 recover
defer func() { helper() }()           // helper 里的 recover 返回 nil

// ✅ 有效：recover 必须在 defer 的函数字面量里【直接】调用
defer func() { if r := recover(); r != nil { } }()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

func nestedPanic() {
	defer fmt.Println("outer defer runs")
	defer func() {
		if r := recover(); r != nil {
			fmt.Println("inner recovered:", r)
			panic("re-panic from defer")
		}
	}()
	panic("original")
}

1
2
3

inner recovered: original
outer defer runs
caught re-panic: re-panic from defer

1
2
3
4
5
6
7
8

func sentinelErr() (err error) {
	defer func() {
		if r := recover(); r != nil {
			err = fmt.Errorf("converted panic: %v", r)
		}
	}()
	panic("kaboom")
}

1

sentinelErr: converted panic: kaboom

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

func counter() func() int {
	n := 0
	return func() int {
		n++
		return n
	}
}

c := counter()
fmt.Println(c(), c(), c())   // 1 2 3
c2 := counter()
fmt.Println(c2())            // 1，独立的环境

1
2
3
4
5

x := 1
inc := func() { x++ }
read := func() int { return x }
inc()
fmt.Println(read())   // 2，两个闭包共享同一个 x

1
2
3
4
5
6

// 🛑 并发下数据竞争
var wg sync.WaitGroup
for i := range 10 {
	wg.Add(1)
	go func() { defer wg.Done(); counter++ }()   // counter 竞争
}