Go 语言内核

不教基础概念。下面每一节只回答三个问题：Go 里怎么写、和 C/C++/PHP/Java 差在哪、你最容易踩的坑是什么。所有代码在 1.27.2 下均可直接运行。

1.1 先建好本模块的练习目录

打开 PowerShell，执行（整个模块都在这个目录里练）：

mkdir D:\go10 ; cd D:\go10
go mod init go10        # 生成 go.mod（内容见 §02）
go version              # 应输出 go version go1.27.x windows/amd64

1.2 变量与类型：声明反着写、零值是默认

// D:\go10\01_var.go —— go run .\01_var.go
package main

import "fmt"

func main() {
	var a int = 42
	b := 3.14               // 短声明，类型自动推断为 float64
	var s string            // 零值 ""，不是 null/野值
	const Pi = 3.14159

	fmt.Println(a, b, s == "", Pi)   // 输出: 42 3.14 true 3.14159

	// 没有隐式转换：int 与 float64 相加必须显式转
	c := float64(a) + b
	fmt.Println(c)          // 45.14
}

1.3 控制流：没有 while/三目，if 可以带初始化语句

1.4 函数：多返回值 + error 惯例是 Go 的灵魂

// D:\go10\02_func.go
package main

import (
	"errors"
	"fmt"
)

// 多返回值：(结果, 错误) 是全行业惯例
func divide(a, b float64) (float64, error) {
	if b == 0 {
		return 0, errors.New("b must not be zero")  // 错误是普通值
	}
	return a / b, nil
}

// 命名返回值 + defer（见 1.7）
func parseInt(s string) (n int, err error) {
	defer func() { fmt.Println("defer: return", n, err) }()
	if s == "" {
		err = errors.New("empty input")   // 命名返回值被 defer 看见
		return
	}
	n = 7
	return
}

func main() {
	v, err := divide(10, 0)
	if err != nil {                       // 错误必须显式处理，编译器盯着你
		fmt.Println("error:", err)        // error: b must not be zero
	} else {
		fmt.Println(v)
	}

	// "_" 丢弃返回值；但 error 永远不要随便丢
	_, e := parseInt("")
	fmt.Println("err =", e)              // err = empty input
}

1.5 结构体与方法：方法是"带接收者的函数"

// D:\go10\03_struct.go
package main

import "fmt"

type User struct {
	Name string
	Age  int
}

// 值接收者：操作副本（类似 Java 传值）
func (u User) Greet() string { return "hi, " + u.Name }

// 指针接收者：改原值。要修改状态就用指针接收者，全 struct 保持一致
func (u *User) Birthday() { u.Age++ }

// 构造函数：Go 没有构造器惯例——写 NewXxx 函数
func NewUser(name string, age int) *User {
	return &User{Name: name, Age: age}
}

func main() {
	u := NewUser("Ada", 30)
	u.Birthday()
	fmt.Println(u.Greet(), u.Age)   // hi, Ada 31

	// 结构体字面量
	p := struct{ X, Y int }{3, 4}
	fmt.Println(p)
}

铁律：一个类型的所有方法，要么全用值接收者、要么全用指针接收者，不要混——混了会在接口实现上出问题（§03）。

1.6 接口：隐式实现（duck typing），没有 implements 关键字

// D:\go10\04_iface.go
package main

import "fmt"

type Speaker interface {            // 定义接口：一组方法签名
	Speak() string
}

type Dog struct{ Name string }
type Cat struct{ Name string }

// Dog 实现了 Speak() —— 它就自动是 Speaker，什么都不用声明
func (d Dog) Speak() string { return d.Name + ": woof" }
func (c Cat) Speak() string { return c.Name + ": meow" }

func introduce(s Speaker) { fmt.Println(s.Speak()) }

func main() {
	introduce(Dog{"Rex"})   // Rex: woof
	introduce(Cat{"Tom"})   // Tom: meow
}

1.7 defer：注册"函数退出前一定执行"的清理动作

// D:\go10\05_defer.go
package main

import "fmt"

func main() {
	fmt.Println("start")
	defer fmt.Println("defer 1")    // 压栈：LIFO 顺序执行
	defer fmt.Println("defer 2")
	fmt.Println("end")
	// 输出顺序: start → end → defer 2 → defer 1
}

• 典型用途：f, _ := os.Open(p); defer f.Close()——哪怕中途 return 或 panic，Close 一定执行。
• 多个 defer 是后进先出（栈）。
• 参数立即求值：defer fmt.Println(time.Now()) 记录的是 defer 注册时刻的时间，不是执行时刻。要延迟求值就包一层闭包。

1.8 指针：比 C 简单——没有指针算术

// D:\go10\06_ptr.go
package main

import "fmt"

func inc(n int)    { n++ }              // 传值：外面不变
func incp(n *int)  { *n++ }             // 传指针：外面变

func main() {
	x := 10
	inc(x)
	fmt.Println(x)        // 10（副本+1）
	incp(&x)
	fmt.Println(x)        // 11

	p := &x
	*p = 99
	fmt.Println(x)        // 99
}

与 C 的差异：① 没有指针算术（p++ 编译不过）——这是 Go 安全模型的根基；② new(T) 返回 *T，但更常用 &T{...}；③ GC 自动回收，不用 free；④ slice/map/channel/func 本身是引用语义的"描述符"，传参时别再包一层指针。

1.9 字符串、slice、map：三个"内置引用类型"

// D:\go10\07_coll.go
package main

import (
	"fmt"
	"strings"
)

func main() {
	// string：UTF-8 只读字节序列。rune 遍历拿码点
	s := "你好Go"
	for _, r := range s { fmt.Printf("%c ", r) }   // 你 好 G o
	fmt.Println(len(s))                            // 8：字节数不是字符数！

	// slice：动态数组 = (指针, len, cap)。append 是最常见的扩容场景
	names := []string{"Ada", "Bob"}
	names = append(names, "Cid")
	fmt.Println(strings.Join(names, ","))          // Ada,Bob,Cid

	// make 预分配容量，避免反复扩容（性能常识）
	buf := make([]int, 0, 100)

	// map：哈希表，make 后才能写
	m := make(map[string]int)
	m["apple"] = 3
	v, ok := m["apple"]      // comma-ok 判断存在，别用 ok==false 当错误
	fmt.Println(v, ok)        // 3 true
}

1.10 错误处理哲学：error 是值，panic 是给程序员看的

// error wrap 与判定（Go 1.13+ ，1.27 照用）
err := fmt.Errorf("save user: %w", os.ErrNotExist)
errors.Is(err, os.ErrNotExist)   // true：沿 wrap 链找

Go 1.27 强制 module 模式（GOPATH 模式已死）。你只需要理解两个文件、五条命令、一个代理。

2.1 go.mod 与 go.sum 是什么

# D:\go10\go.mod（go mod init go10 自动生成，本模块零第三方依赖）
module go10

go 1.27

# 将来引入 Gin 后会变成：
# require github.com/gin-gonic/gin v1.12.0

按版本纪律（08 §7）：go.sum 入库即冻结，AI 建议升级默认拒绝。本模块所有示例只用标准库，零依赖——这是故意的：先把内核练熟，第三方框架（Gin v1.12.x / GORM v1.31.x）在 11 模块才登场。

2.2 五条必记命令（PowerShell 里照抄）

cd D:\go10

# 1) 初始化模块（每个新项目只做一次）
go mod init go10

# 2) 直接跑（单文件或包）
go run .\01_var.go
go run .

# 3) 编译出 exe（输出到当前目录 go10.exe）
go build -o go10.exe .

# 4) 跑测试（见 §06）
go test ./...
go test -race ./...

# 5) 整理依赖：补齐缺失、移除无用（引了新库后必跑）
go mod tidy

2.3 GOPROXY：国内网络一次配好，永久不再 i/o timeout

# 只执行一次（写到用户级 go env 配置里）
go env -w GO111MODULE=on
go env -w GOPROXY=https://goproxy.cn,direct
go env -w GOSUMDB=sum.golang.google.cn

# 验证
go env GOPROXY

goproxy.cn 是七牛维护的国内模块代理，,direct 表示私有仓库直连。配完之后 go mod tidy 才不会卡在 proxy.golang.org（§10 报错 8）。

2.4 模块内 import 路径规则

D:\go10\
├── go.mod                 # module go10
├── main.go                # package main
└── mathutil\
    └── add.go             # package mathutil

// mathutil/add.go
package mathutil

func Add(a, b int) int { return a + b }

// main.go 里 import：路径 = module 路径 + 目录相对路径
import "go10/mathutil"
fmt.Println(mathutil.Add(1, 2))   // 3

• 包名 = 目录名（package mathutil），与目录名一致是惯例。
• 导出规则：大写开头=导出，小写开头=包私有（类似 C 的 static / Java 的 public/private，但由大小写决定）。
• 一个目录只能有一个 package；测试文件可以用 package xxx_test 外部测试包。

本模块练习法：上面 01–07 的示例都放在 D:\go10\ 根目录时，由于它们都是 package main，不要在同一目录放多个 main.go——要么单文件 go run .\01_var.go，要么把每个示例放进自己的子目录。

接口在 §1.6 已经见过。这里补三块硬骨头：类型断言、空接口、Go 1.18+ 泛型（1.27 已是泛型第三代，写法稳定）。

3.1 类型断言与 comma-ok：从接口里掏出具体类型

// D:\go10\08_assert.go
package main

import "fmt"

func describe(x any) {              // any = interface{} 的别名（Go 1.18+）
	switch v := x.(type) {         // 类型断言 + 类型 switch
	case int:
		fmt.Println("int:", v*2)
	case string:
		fmt.Println("string:", v)
	default:
		fmt.Printf("unknown: %T\n", x)   // %T 打印动态类型
	}
}

func main() {
	var i any = "hello"
	s, ok := i.(string)            // comma-ok：断言失败 ok=false，不 panic
	fmt.Println(s, ok)             // hello true

	n, ok := i.(int)               // 失败：n=0, ok=false
	fmt.Println(n, ok)             // 0 false

	describe(42)                   // int: 84
	describe("go")                 // string: go
}

• 单值断言 x.(T) 失败会 panic——对外接口一律用 comma-ok 双值形式。
• any 是空接口的现代别名（Go 1.18+），新代码写 any。
• %T 打印动态类型，调试接口问题的第一工具。

3.2 泛型：写一次，多种类型都能用（Go 1.18+ ，1.27 用法）

// D:\go10\09_generic.go
package main

import "fmt"

// 泛型函数：[K comparable, V any] 是类型参数 + 约束
// comparable = 支持 == 比较（map 的 key 必须满足）
func MapKeys[K comparable, V any](m map[K]V) []K {
	keys := make([]K, 0, len(m))
	for k := range m {
		keys = append(keys, k)
	}
	return keys
}

// 约束用 interface 声明：~int 表示"底层类型是 int 的所有类型"
type Number interface {
	~int | ~int64 | ~float64
}

func Sum[T Number](nums []T) T {
	var total T
	for _, n := range nums {
		total += n
	}
	return total
}

func main() {
	m := map[string]int{"a": 1, "b": 2}
	fmt.Println(MapKeys(m))          // [a b]（顺序不定）

	fmt.Println(Sum([]int{1, 2, 3}))       // 6
	fmt.Println(Sum([]float64{1.5, 2.5}))  // 4
}

你的 Java 直觉：Go 泛型 ≈ Java 泛型的类型参数部分，但没有类型擦除的运行时包袱；Go 的约束是"接口里放方法签名"，比 Java 的 extends 更灵活。

这是 Go 的立身之本，也是你从 C/C++ 过来最需要重建直觉的部分。一句总纲：不要用共享内存来通信，要用通信来共享内存。

4.1 goroutine：一句话起一个"用户态轻量线程"

// D:\go10\10_goroutine.go
package main

import (
	"fmt"
	"time"
)

func say(msg string) {
	for i := 0; i < 3; i++ {
		fmt.Println(msg, i)
		time.Sleep(100 * time.Millisecond)
	}
}

func main() {
	go say("worker")        // go 关键字 = 异步启动，立刻返回
	say("main")              // 主线程同时跑
	// main 一返回，所有 goroutine 直接被杀——所以这里靠 say 阻塞住
}

• 初始栈仅 2KB（操作系统线程通常 1–8MB），起几千个毫无压力。
• main 返回 = 进程退出，子 goroutine 不等你。要等它们就用 WaitGroup 或 channel。

4.2 channel：goroutine 之间的"类型安全管道"

// D:\go10\11_channel.go
package main

import "fmt"

func main() {
	// 无缓冲 channel：发送与接收必须"碰面"才继续
	ch := make(chan string)

	go func() {
		ch <- "hello from goroutine"   // 发送
		close(ch)
	}()

	msg := <-ch                       // 接收
	fmt.Println(msg)                  // hello from goroutine

	// range 读取直到 close
	numCh := make(chan int, 3)        // 缓冲 channel：容量 3
	numCh <- 1; numCh <- 2; numCh <- 3
	close(numCh)
	for n := range numCh {
		fmt.Print(n, " ")             // 1 2 3
	}
}

4.3 select：同时等多个 channel

// D:\go10\12_select.go
package main

import (
	"fmt"
	"time"
)

func main() {
	tick := time.Tick(100 * time.Millisecond)
	boom := time.After(350 * time.Millisecond)

	for {
		select {
		case <-tick:
			fmt.Print("tick ")
		case <-boom:
			fmt.Println("\nBOOM")
			return
		}
	}
	// 输出: tick tick tick BOOM
}

4.4 sync 包：WaitGroup 等批次，Mutex 保护共享数据

// D:\go10\13_sync.go
package main

import (
	"fmt"
	"sync"
)

func main() {
	var wg sync.WaitGroup
	var mu sync.Mutex
	counter := 0

	for i := 0; i < 100; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			mu.Lock()           // 保护 counter：不加锁就 data race
			counter++
			mu.Unlock()
		}()
	}
	wg.Wait()                  // 等 100 个 goroutine 全部结束
	fmt.Println(counter)       // 100
}

• WaitGroup 三动作：Add(n) 必须在 go 之前调用（在 goroutine 内 Add 会 race）；Done() 用 defer 挂；Wait() 阻塞到归零。
• Mutex/RWMutex：共享状态的最后防线。规则：锁的粒度越小越好；不要在持有锁的时候做 IO。
• atomic 包用于单个计数器的无锁加减，比 Mutex 更轻。

4.5 context：跨 goroutine 的"取消信号 + 截止时间 + 请求级数据"

// D:\go10\14_context.go —— 三个核心 API 一眼看懂
package main

import (
	"context"
	"fmt"
	"time"
)

func worker(ctx context.Context, name string) {
	select {
	case <-time.After(2 * time.Second):
		fmt.Println(name, "done")
	case <-ctx.Done():                 // 监听取消信号
		fmt.Println(name, "canceled:", ctx.Err())
	}
}

func main() {
	// 1) WithCancel：手动取消
	ctx1, cancel1 := context.WithCancel(context.Background())
	go worker(ctx1, "c1")
	cancel1()                           // 立刻取消

	// 2) WithTimeout：到点自动取消
	ctx2, cancel2 := context.WithTimeout(context.Background(), 100*time.Millisecond)
	defer cancel2()                     // 哪怕没超时也必须调 cancel，释放资源
	go worker(ctx2, "c2")

	// 3) WithValue：请求级数据（只放请求域数据，不要当参数袋）
	ctx3 := context.WithValue(context.Background(), "trace-id", "abc-123")
	fmt.Println("trace-id =", ctx3.Value("trace-id"))

	time.Sleep(500 * time.Millisecond)
}

这是本模块的"毕业作品"，也是 §09 验收标准的默写对象。下面是完整可运行的 stdlib 版本，零第三方依赖。逐文件复制。

5.1 项目结构

D:\grace\
├── go.mod
└── main.go

5.2 go.mod

module grace

go 1.27

5.3 main.go（逐行注释）

// D:\grace\main.go
package main

import (
	"context"
	"log"
	"net/http"
	"os/signal"
	"syscall"
	"time"
)

func main() {
	// ① 根 context：Ctrl+C 或 kill 信号到达时自动取消
	ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
	defer stop()

	// ② 业务 handler：每个请求都带自己的 ctx
	mux := http.NewServeMux()
	mux.HandleFunc("/work", func(w http.ResponseWriter, r *http.Request) {
		reqCtx := r.Context()       // 客户端断开 → reqCtx 自动取消
		log.Println("work start")
		select {
		case <-time.After(2 * time.Second):
			w.Write([]byte("work done\n"))
			log.Println("work finished")
		case <-reqCtx.Done():
			log.Println("work canceled:", reqCtx.Err())
		}
	})
	mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) {
		w.Write([]byte("ok\n"))
	})

	srv := &http.Server{Addr: ":8080", Handler: mux}

	// ③ 异步启动 HTTP 服务（ListenAndServe 是阻塞的）
	go func() {
		log.Println("listening on http://localhost:8080")
		if err := srv.ListenAndServe(); err != http.ErrServerClosed {
			log.Fatalf("server crashed: %v", err)
		}
	}()

	// ④ 主 goroutine 挂起，等信号到达
	<-ctx.Done()
	log.Println("shutdown signal received, draining ...")

	// ⑤ 宽限 5 秒：等在飞请求处理完，再退出
	shutdownCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()
	if err := srv.Shutdown(shutdownCtx); err != nil {
		log.Printf("graceful shutdown error: %v", err)
	}
	log.Println("server exited gracefully")
}

5.4 跑起来 + 验收动作（PowerShell 三个窗口）

# 窗口 A：启动服务
cd D:\grace
go run .

# 窗口 B：发一个慢请求（2 秒才返回）
curl.exe http://localhost:8080/work

# 窗口 B 立刻再开：健康检查
curl.exe http://localhost:8080/healthz

然后：在窗口 B 的 /work 还没返回时，到窗口 A 按 Ctrl+C。你应该看到：

• shutdown signal received, draining ... 打印；
• 在飞请求要么自然完成、要么在 5 秒宽限内被取消并打日志；
• 最后打印 server exited gracefully，进程干净退出（而不是硬杀留下半截响应）。

为什么这个例子值得默写：它同时覆盖了 ① goroutine 启动服务 ② signal 接 ctx ③ handler 用 r.Context() 响应客户端断开 ④ WithTimeout 做退出宽限 ⑤ Shutdown 优雅收尾——五个高频知识点一次串通。这就是 11 工作台实战里 main.go 的雏形。

Go 自带 testing 包，不需要任何第三方框架。掌握三件事：表驱动写法、HTTP 测试、race 检测器。

6.1 表驱动测试：Go 测试的头号惯例

// D:\grace\math_test.go（与 main.go 同目录，package main）
package main

import "testing"

func add(a, b int) int { return a + b }

func TestAdd(t *testing.T) {
	cases := []struct {
		name string
		a, b int
		want int
	}{
		{"1+1", 1, 1, 2},
		{"负数", -1, -2, -3},
		{"零", 0, 0, 0},
	}
	for _, c := range cases {
		t.Run(c.name, func(t *testing.T) {     // 子测试：单独跑某一条
			if got := add(c.a, c.b); got != c.want {
				t.Errorf("add(%d,%d) = %d, want %d", c.a, c.b, got, c.want)
			}
		})
	}
}

go test -v ./...          # -v 打印每个子测试
go test -run TestAdd -v   # 只跑匹配的测试

6.2 httptest：不真起服务器测 handler

// D:\grace\handler_test.go
package main

import (
	"net/http"
	"net/http/httptest"
	"testing"
)

func TestHealthz(t *testing.T) {
	req := httptest.NewRequest(http.MethodGet, "/healthz", nil)
	rec := httptest.NewRecorder()

	mux := http.NewServeMux()
	mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) {
		w.Write([]byte("ok\n"))
	})
	mux.ServeHTTP(rec, req)

	if rec.Code != http.StatusOK {
		t.Fatalf("code = %d", rec.Code)
	}
	if body := rec.Body.String(); body != "ok\n" {
		t.Errorf("body = %q", body)
	}
}

6.3 go test -race：自动抓数据竞争

# 在你的并发代码上必跑一次
go test -race ./...

# 如果有竞争，你会看到类似：
# WARNING: DATA RACE
# Read at 0x00c0001a2xxx by goroutine 7:
#   previous write ...

-race 是 Go 赠送的免费正餐：你的 C/C++ 经验里要靠 ThreadSanitizer 才能做的事，这里 go test -race 一条命令。提交任何并发代码前必须过 -race。

你的 C/C++ 直觉会想上 perf/VS Profiler——Go 标准库自带 net/http/pprof，挂一行 import 就能采 CPU/堆/goroutine 数据。

7.1 挂到服务上（在 §05 的 main.go 上加 3 行）

import (
	_ "net/http/pprof"     // 匿名导入：自动注册 /debug/pprof 路由
)

func main() {
	// 另起一个端口专给 pprof（不对外暴露）
	go func() {
		log.Println("pprof on :6060")
		_ = http.ListenAndServe("localhost:6060", nil)
	}()
	// ... 原服务代码不变
}

7.2 采集与分析（服务跑着的时候，另开 PowerShell）

# 1) 看一次堆快照（哪块内存多）
go tool pprof http://localhost:6060/debug/pprof/heap

# 进入 pprof 交互界面后：
(pprof) top          # 占用最高的 10 个函数
(pprof) list main    # 看 main 包里哪一行烧内存
(pprof) web          # 生成调用图（需装 graphviz）
(pprof) exit

# 2) 采 30 秒 CPU（哪段代码烧 CPU）
go tool pprof http://localhost:6060/debug/pprof/profile?seconds=30

# 3) 看 goroutine 泄露
go tool pprof http://localhost:6060/debug/pprof/goroutine?debug=2

入门套路：先 heap 后 CPU——内存问题看 heap，速度问题看 profile。阶段四（机制深潜）会再带你读 runtime 源码，本阶段只要做到"会挂、会采、会 top"就够。

与 08 总纲 §3 的每日模板对齐：每天 8 个 30 分钟块。理论只读 1 块，其余 7 块在敲代码。

8.1 第 1 周：从语法到并发核心（D1–D7）

8.2 第 2 周：测试、剖析、综合项目、默写验收（D8–D14）

8.3 14 天总览

08 总纲给阶段一的验收只有一句话："能默写带 context 取消与优雅停机的并发服务"。下面是它的展开版——12 项全过才算本模块毕业。

补考规则：任何一项不过，回到 §8 对应那一天重练，不要带着漏洞进 11 工作台——11 模块的 main.go 就是 §05 的扩展版，这里默写不过去，11 会卡死。

闭关期间 90% 的卡点都在这张表里。卡住了先查这张，不要跳出教程。

还卡住？把完整报错原文 + 复现命令 + 相关代码段，按 08 §6 的"打包证据给 AI"流程处理——不要凭感觉瞎改。

本页所有结论的外部事实来源如下；教学结构（14 天计划、对照表写法、验收清单）为编者基于 07/08 的执行化设计。

（编者整理：本页 14 天计划、对照表、验收清单、报错表为基于 07 报告与 08 总纲的执行化设计，无外部独立来源。）