第01章 · Go 基础语法（正式版）

# 新建一个目录当作我们的第一个项目
mkdir -p ~/code/webook-syntax && cd ~/code/webook-syntax

# 初始化模块：模块名通常写成"代码仓库地址/项目名"
go mod init github.com/yourname/webook-syntax

# 看看生成了什么
cat go.mod

// 文件路径: ~/code/webook-syntax/main.go
// 每一个 Go 文件都必须以 package 声明开头
package main

import "fmt"

// main 函数无参数、无返回值，这是 Go 程序的唯一入口
func main() {
	fmt.Println("Hello, Go!")
}

go run main.go

package hello // ← 故意写错

import "fmt"

func main() {
	fmt.Println("Hello, Go!")
}

func main()
{                       // ← 编译报错！
	fmt.Println("hi")
}

import (
	"fmt"
	"os" // ← 导入了但没用
)

func main() {
	x := 1 // ← 声明了但没用
	fmt.Println("hi")
}

# 方式一：直接运行（适合开发期）
go run main.go        # 单文件
go run .              # 整个目录

# 方式二：先编译成二进制，再运行（部署用）
go build -o webook .  # 生成可执行文件 webook
./webook              # 运行它

var userId int64 = 100
var offset int = 10
fmt.Println(userId + offset) // 你以为会输出 110

// 文件路径: ~/code/webook-syntax/type_demo/main.go
package main

import (
	"fmt"
	"math"
	"strconv"
)

func main() {
	var userId int64 = 100
	var offset int = 10

	// 错误写法：sum := userId + offset  // 编译报错：mismatched types

	// 正确写法：显式转换
	sum := userId + int64(offset)
	fmt.Println("sum =", sum)

	// 看看 int 在你的机器上有多宽（返回 bit 数）
	fmt.Println("int 宽度(bit):", strconv.IntSize) // 64 位机器上是 64

	fmt.Println("MaxInt64 =", int64(math.MaxInt64))
}

// 文件路径: ~/code/webook-syntax/string_demo/main.go
package main

import (
	"fmt"
	"unicode/utf8"
)

func main() {
	s := "你好，Go"

	// len 返回的是字节长度，不是字符个数
	fmt.Println("len(s) =", len(s))

	// 字符个数要用 utf8.RuneCountInString
	fmt.Println("字符数 =", utf8.RuneCountInString(s))

	// 遍历字符（rune），而不是字节
	fmt.Println("--- 逐字符遍历 ---")
	for i, r := range s {
		fmt.Printf("字节下标 %d: %c\n", i, r)
	}
}

s := "你好，Go"
fmt.Println(s[:5]) // 危险！

package main

import "fmt"

func main() {
	s := "你好，Go"

	// 正确：先转成 rune 切片，再按"字符"截断
	runes := []rune(s)
	fmt.Println(string(runes[:2])) // 你好
}

// 文件路径: ~/code/webook-syntax/string_demo/ops.go
package main

import (
	"fmt"
	"strings"
)

func main() {
	// 1. 双引号：内部出现 " 要用 \ 转义
	s1 := "他说：\"你好\""
	fmt.Println(s1)

	// 2. 反引号：可以换行、不用转义，但内部不能出现反引号
	s2 := `第一行
第二行`
	fmt.Println(s2)

	// 3. 拼接只能用 +，且 string 不能和数字直接拼（强类型！）
	fmt.Println("hello, " + "go")
	// fmt.Println("age: " + 18)  // 编译报错！要先转换

	// 4. 日常操作全在 strings 包里
	fmt.Println(strings.Contains("hello", "ell"))      // true
	fmt.Println(strings.ReplaceAll("a-b-c", "-", "+")) // a+b+c
	fmt.Println(strings.ToUpper("go"))                 // GO
	fmt.Println(strings.Split("a,b,c", ","))           // [a b c]
	fmt.Println(strings.TrimSpace("  hi  "))           // hi

	// 5. []byte 和 string 互转
	b := []byte("hello")
	fmt.Println(string(b) == "hello") // true
}

// 文件路径: ~/code/webook-syntax/const_demo/main.go
package main

import "fmt"

// 包级变量：首字母大写 = 包外可访问（导出）；小写 = 包内私有
var ServerPort int = 8080
var serverSecret = "xxx"

// const 同样遵循大小写控制访问性
const MaxRetry = 3

// iota：常量计数器，每个 const 块重置为 0，每新增一行 +1
type Weekday int

const (
	Sunday Weekday = iota // 0
	Monday                // 1
	Tuesday               // 2
	Wednesday             // 3
	Thursday              // 4
	Friday                // 5
	Saturday              // 6
)

// 位掩码：权限位的经典写法
const (
	Read    = 1 << iota // 1 << 0 = 1
	Write               // 1 << 1 = 2
	Execute             // 1 << 2 = 4
)

func main() {
	// 局部变量两种声明方式
	var a int = 10 // 显式类型
	b := 20        // 短变量声明，只能用在函数内部

	// := 要求左侧至少有一个新变量
	b, c := 30, 40 // b 已存在但 c 是新的，所以合法

	fmt.Println(a, b, c)
	fmt.Println("Friday =", Friday)
	fmt.Println("Read|Write =", Read|Write)
}

// 文件路径: ~/code/webook-syntax/const_demo/bool.go
package main

import "fmt"

func main() {
	a, b := true, false

	// 德摩根定律：验证组合取反
	fmt.Println(!(a && b) == (!a || !b)) // true
	fmt.Println(!(a || b) == (!a && !b)) // true

	i := 0
	i++ // 合法：i++ 是语句
	// x := i++ // 编译报错：syntax error
	_ = i
}

// 文件路径: ~/code/webook-syntax/recursion/main.go
package main

import "fmt"

// 递归求阶乘，递归深度 = n
func factorial(n int) int {
	if n <= 1 {
		return 1 // 递归出口
	}
	return n * factorial(n-1)
}

func main() {
	fmt.Println(factorial(5))
}

func main() {
	x := 1
	defer fmt.Println("参数传值:", x)
	defer func() { fmt.Println("闭包引用:", x) }()
	x = 3
}

// 文件路径: ~/code/webook-syntax/defer_demo/main.go
package main

import "fmt"

func main() {
	x := 1

	// 作为参数传入：定义 defer 时就确定了值
	defer fmt.Println("param x =", x)

	// 作为闭包引用：执行 defer 时才确定值
	defer func() {
		fmt.Println("closure x =", x)
	}()

	x = 2
	fmt.Println("before return, x =", x)
	x = 3
}

// 文件路径: ~/code/webook-syntax/defer_demo/return.go
package main

import "fmt"

// 匿名返回值：return 那一刻值就被拷贝出去了，defer 改不到
func anonymous() int {
	var a int
	defer func() {
		a = 100 // 改的只是局部变量 a
	}()
	return a // 返回 0
}

// 有名返回值：result 本身就是"返回值变量"，defer 改它就是改返回值
func named() (result int) {
	defer func() {
		result = 100
	}()
	return 1 // 先执行 result = 1，defer 再改成 100
}

func main() {
	fmt.Println(anonymous())
	fmt.Println(named())
}

// 文件路径: ~/code/webook-syntax/defer_demo/divide.go
package main

import "fmt"

// 多返回值 + 有名返回值
func divide(a, b int) (result int, err error) {
	defer func() {
		// recover 捕获 panic，让函数返回 err 而不是崩溃
		if r := recover(); r != nil {
			err = fmt.Errorf("panic: %v", r)
			result = 0
		}
	}()
	if b == 0 {
		return 0, fmt.Errorf("divisor is zero")
	}
	return a / b, nil
}

func main() {
	fmt.Println(divide(10, 2))
	fmt.Println(divide(10, 0))
}

// 文件路径: ~/code/webook-syntax/defer_demo/closure.go
package main

import "fmt"

// counter 返回一个闭包，它"捕获"了外部的 count 变量
func counter() func() int {
	count := 0
	return func() int {
		count++
		return count
	}
}

func main() {
	c := counter()
	fmt.Println(c(), c(), c()) // 1 2 3

	c2 := counter()
	fmt.Println(c2()) // 1 —— 新的闭包有独立的 count
}

package main

import "fmt"

// 不定参数：必须是最后一个参数；方法内部当切片用
func sum(nums ...int) int {
	total := 0
	for _, n := range nums {
		total += n
	}
	return total
}

func main() {
	fmt.Println(sum(1, 2, 3, 4)) // 10
	fmt.Println(sum())           // 0 —— 可以传 0 个值

	nums := []int{1, 2, 3}
	fmt.Println(sum(nums...)) // 6 —— 切片展开传入
}

// 文件路径: ~/code/webook-syntax/control/main.go
package main

import "fmt"

func main() {
	// if 支持初始化语句，作用域仅限于 if-else 块
	if distance := 100; distance > 50 {
		fmt.Println("far")
	} else {
		fmt.Println("near")
	}
	// distance 在这里不可用（出了作用域）

	// for 形态一：经典三段式
	for i := 0; i < 3; i++ {
		fmt.Println("三段式:", i)
	}

	// for 形态二：while 风格
	n := 0
	for n < 3 {
		fmt.Println("while 风格:", n)
		n++
	}

	// for 形态三：range 遍历
	nums := []int{10, 20, 30}
	for idx, val := range nums {
		fmt.Printf("nums[%d]=%d\n", idx, val)
	}
}

// 文件路径: ~/code/webook-syntax/control/range.go
package main

import "fmt"

func main() {
	nums := []int{10, 20, 30}

	// 错误写法：对迭代变量取地址
	bad := make([]*int, 0, len(nums))
	for _, v := range nums {
		bad = append(bad, &v) // 所有指针都指向同一个地址！
	}
	fmt.Println("bad:", *bad[0], *bad[1], *bad[2])

	// 正确写法：循环体内创建局部变量
	good := make([]*int, 0, len(nums))
	for _, v := range nums {
		v := v // 每次循环创建新的局部变量
		good = append(good, &v)
	}
	fmt.Println("good:", *good[0], *good[1], *good[2])
}

go version

// 文件路径: ~/code/webook-syntax/control/loop.go
package main

import "fmt"

func main() {
	// continue：跳过本次循环剩余部分
	for i := 0; i < 5; i++ {
		if i%2 == 0 {
			continue
		}
		fmt.Println("odd:", i)
	}

	// break：中断整个循环
	for i := 0; i < 5; i++ {
		if i == 2 {
			break
		}
		fmt.Println("i =", i)
	}

	// 无限循环 + break 退出
	n := 0
	for {
		n++
		if n >= 3 {
			break
		}
	}
	fmt.Println("无限循环退出，n =", n)
}

// 文件路径: ~/code/webook-syntax/control/switch.go
package main

import "fmt"

func main() {
	// 形态一：带值 switch（val 必须是"可比较的"）
	switch day := "Mon"; day {
	case "Mon", "Tue", "Wed", "Thu", "Fri":
		fmt.Println("weekday")
	case "Sat", "Sun":
		fmt.Println("weekend")
	default:
		fmt.Println("unknown")
	}

	// 形态二：无值 switch（等价于一长串 if-else if）
	hour := 8
	switch {
	case hour < 9:
		fmt.Println("早高峰")
	case hour < 18:
		fmt.Println("工作时间")
	default:
		fmt.Println("下班了")
	}
}

s := []int{1, 2, 3, 4, 5}
sub := s[:2]
sub[0] = 999
fmt.Println(s[0]) // 是 1 还是 999？

// 这是 Go 运行时的真实定义（在 reflect 包里）
type SliceHeader struct {
	Data uintptr // 指向底层数组的指针
	Len  int     // 当前元素个数
	Cap  int     // 底层数组的容量
}

// 文件路径: ~/code/webook-syntax/slice_demo/main.go
package main

import "fmt"

func main() {
	s := make([]int, 3, 5) // len=3, cap=5
	s[0], s[1], s[2] = 1, 2, 3
	fmt.Printf("初始: s=%v len=%d cap=%d\n", s, len(s), cap(s))

	// 步骤 1：取子切片，与原切片共享同一底层数组
	sub := s[:2]
	sub[0] = 999
	fmt.Println("改 sub[0] 后，s[0] =", s[0])

	// 步骤 2：append 没超过 cap，仍在共享的底层数组上写
	sub = append(sub, 100)
	fmt.Println("sub append 后，s[2] =", s[2])

	// 步骤 3：append 超过 cap，触发扩容，不再共享
	big := append(s, 4, 5, 6) // 需要 6 个位置 > cap 5，触发扩容
	big[0] = 0
	fmt.Println("扩容后改 big[0]，s[0] =", s[0])
}

// 危险写法
func first10(big []int) []int {
	return big[:10] // 看似只返回 10 个元素
}

// 正确写法：copy 出独立切片，切断引用
func first10Safe(big []int) []int {
	small := make([]int, 10)
	copy(small, big[:10])
	return small
}

// 文件路径: ~/code/webook-syntax/slice_demo/leak.go
package main

import (
	"crypto/rand"
	"fmt"
	"runtime"
)

func printMem(tag string) {
	var m runtime.MemStats
	runtime.GC()
	runtime.ReadMemStats(&m)
	fmt.Printf("%s 堆内存 = %d KB\n", tag, m.HeapAlloc/1024)
}

// 危险：返回子切片，底层大数组无法释放
func leak() []byte {
	big := make([]byte, 50*1024*1024) // 50 MB
	_, _ = rand.Read(big)             // 用真实 IO 填数据，防止编译器把"没人读的部分"优化掉
	return big[:10]
}

// 安全：copy 出独立切片
func safe() []byte {
	big := make([]byte, 50*1024*1024)
	_, _ = rand.Read(big)
	small := make([]byte, 10)
	copy(small, big[:10])
	return small
}

func main() {
	printMem("初始    ")

	kept := leak() // 持有返回的小切片
	printMem("leak 后 ")  // 50MB 依然被钉住
	runtime.KeepAlive(kept) // 让编译器认为 kept 到这一刻仍被使用，否则会被提前回收

	kept = nil      // 释放引用
	runtime.GC()
	printMem("leak 释放")

	kept2 := safe()
	printMem("safe 后 ") // 大数组已被回收
	runtime.KeepAlive(kept2)
}

// 差：从 0 开始反复 append，可能触发多次扩容 + 数据拷贝
var users []User
for _, u := range source {
	users = append(users, u)
}

// 好：一次分配到位，零扩容
users := make([]User, 0, len(source))
for _, u := range source {
	users = append(users, u)
}

// 文件路径: ~/code/webook-syntax/map_demo/main.go
package main

import "fmt"

func main() {
	// 预估容量能提升性能
	m := make(map[string]int, 64)

	// 赋值
	m["a"] = 1
	m["b"] = 2

	// 读取：两返回值，第二个表示是否存在
	// 不存在的 key 返回零值，不会 panic
	v, ok := m["c"]
	fmt.Println("读不存在的 key:", v, ok)

	// 遍历：顺序随机！
	fmt.Print("遍历: ")
	for k, v := range m {
		fmt.Print(k, "=", v, "  ")
	}
	fmt.Println()

	// 删除
	delete(m, "a")
	fmt.Println("删除后长度:", len(m))
}

// 方式一：make 初始化——可以预估容量，避免运行中反复扩容（推荐）
m1 := make(map[string]int, 64)

// 方式二：字面量初始化——适合"内容一开始就确定"的小 map
m2 := map[string]int{
	"apple":  1,
	"banana": 2,
}

// 文件路径: ~/code/webook-syntax/map_demo/nilmap.go
package main

import "fmt"

func main() {
	// 切片：不初始化也能 append（Go 内部帮你分配底层数组）
	var s []int
	s = append(s, 1)
	fmt.Println("切片 append OK:", s)

	// map：不初始化就写入，直接 panic
	var m map[string]int
	fmt.Println("nil map 可以读:", m["x"]) // OK，返回 0
	fmt.Println("nil map 可以 len:", len(m)) // OK，返回 0
	for k := range m { // OK，空转
		_ = k
	}

	// m["a"] = 1  // ← 取消注释会 panic: assignment to entry in nil map
}

import "sync"

// 方案一：自己加锁（适合读多写少、类型明确的场景）
type SafeCache struct {
	mu sync.RWMutex
	m  map[string]int
}

func (c *SafeCache) Get(k string) (int, bool) {
	c.mu.RLock() // 读锁：多个读者可以并行
	defer c.mu.Unlock()
	v, ok := c.m[k]
	return v, ok
}

func (c *SafeCache) Set(k string, v int) {
	c.mu.Lock() // 写锁：独占
	defer c.mu.Unlock()
	c.m[k] = v
}

// 方案二：用 sync.Map。官方推荐的两个场景：
//   ① 某个 key 只写一次、之后以读为主（只增不改的缓存）；
//   ② 多个 goroutine 各自读写"不相交"的 key 集合。
// 如果读写都频繁且集中在同一批 key 上，方案一（mutex + map）通常更快。
var sm sync.Map

func demo() {
	sm.Store("a", 1)
	if v, ok := sm.Load("a"); ok {
		fmt.Println(v)
	}
}

// 文件路径: ~/code/webook-syntax/map_demo/sorted.go
package main

import (
	"fmt"
	"sort"
)

func main() {
	m := map[string]int{"banana": 2, "apple": 1, "orange": 3}

	keys := make([]string, 0, len(m))
	for k := range m {
		keys = append(keys, k)
	}
	sort.Strings(keys) // 排序

	for _, k := range keys {
		fmt.Println(k, m[k])
	}
}

// 文件路径: ~/code/webook-syntax/set/set.go
package set

// 用泛型实现一个通用的 Set
// K 必须是 comparable，因为要作为 map 的 key
type Set[K comparable] struct {
	m map[K]struct{} // struct{} 不占内存
}

func New[K comparable]() *Set[K] {
	return &Set[K]{m: make(map[K]struct{})}
}

func (s *Set[K]) Add(k K) {
	s.m[k] = struct{}{}
}

func (s *Set[K]) Delete(k K) {
	delete(s.m, k)
}

func (s *Set[K]) Contains(k K) bool {
	_, ok := s.m[k]
	return ok
}

func (s *Set[K]) Len() int {
	return len(s.m)
}

// Keys 返回所有元素，注意 map 遍历随机，结果顺序不固定
func (s *Set[K]) Keys() []K {
	keys := make([]K, 0, len(s.m))
	for k := range s.m {
		keys = append(keys, k)
	}
	return keys
}

// 文件路径: ~/code/webook-syntax/set_demo/main.go
// 注意：demo 必须放在 set 包目录之外的独立目录（如 set_demo/），
// 否则会和 set/set.go 的 package set 冲突，也无法 import 自己所在的包
package main

import (
	"fmt"
	"sort"

	"github.com/yourname/webook-syntax/set"
)

func main() {
	s := set.New[string]()
	s.Add("go")
	s.Add("gin")
	s.Add("go") // 重复添加，Set 会自动去重

	fmt.Println("元素个数:", s.Len())           // 2
	fmt.Println("包含 go 吗:", s.Contains("go")) // true

	s.Delete("gin")
	fmt.Println("删除后个数:", s.Len()) // 1

	keys := s.Keys()
	sort.Strings(keys) // 排序后输出才稳定
	fmt.Println("剩余元素:", keys)
}

type Repository interface {
	Save(key string, value []byte) error
}

type MySQLRepository struct{ /* ... */ }

func (m *MySQLRepository) Save(key string, value []byte) error {
	// 写 MySQL
	return nil
}

// 这里居然能赋值？
var r Repository = &MySQLRepository{}

// 文件路径: ~/code/webook-syntax/interface_demo/main.go
package main

import "fmt"

// 接口只声明方法，不需要 func 关键字
type Repository interface {
	Save(key string, value []byte) error
	Load(key string) ([]byte, error)
}

// 实现一：内存存储
type MemoryRepository struct {
	data map[string][]byte
}

func NewMemoryRepository() *MemoryRepository {
	return &MemoryRepository{data: make(map[string][]byte)}
}

func (m *MemoryRepository) Save(key string, value []byte) error {
	m.data[key] = value
	return nil
}

func (m *MemoryRepository) Load(key string) ([]byte, error) {
	v, ok := m.data[key]
	if !ok {
		return nil, fmt.Errorf("key %s not found", key)
	}
	return v, nil
}

// 业务代码：只依赖接口，不关心具体实现
func RunBusiness(r Repository) {
	r.Save("name", []byte("大明"))
	v, _ := r.Load("name")
	fmt.Println("读出来:", string(v))
}

func main() {
	// 没有 implements，直接赋值——因为方法集满足
	var repo Repository = NewMemoryRepository()
	RunBusiness(repo)
}

// 文件路径: ~/code/webook-syntax/interface_demo/user.go
package main

import "time"

type User struct {
	ID        int64
	Name      string
	Email     string
	CreatedAt time.Time
}

// 指针接收器：方法内修改字段会生效
func (u *User) Rename(newName string) {
	u.Name = newName
}

// 值接收器：方法内拿到的是副本，修改不会生效
func (u User) NameLength() int {
	return len(u.Name)
}

// Go 没有构造函数！通常用 NewXXX 函数代替
func NewUser(name, email string) *User {
	return &User{
		Name:      name,
		Email:     email,
		CreatedAt: time.Now(),
	}
}

// 文件路径: ~/code/webook-syntax/struct_demo/init.go
// 说明：这是一个独立的演示程序（有自己的 User 和 main），
// 请放在单独目录里运行，不要和 interface_demo/ 下的 main.go、user.go 放一起，
// 否则 User 和 main 会重复声明导致编译失败
package main

import "fmt"

type User struct {
	ID   int64
	Name string
}

func main() {
	// 步骤 1：按字段名初始化（强烈推荐）
	u1 := User{ID: 1, Name: "大明"}

	// 步骤 2：按字段顺序初始化（不推荐）
	u2 := User{1, "小明"}

	// 步骤 3：三种拿到指针的写法
	p1 := &User{ID: 2} // 取字面量地址
	p2 := new(User)    // new 分配内存、所有字段置零值，返回指针

	fmt.Println(u1, u2, p1, p2)

	// 步骤 4：声明了指针但没赋值，它是 nil
	var p3 *User
	fmt.Println("p3 == nil ?", p3 == nil)
}

type Node struct {
	Value int
	Next  *Node // ✅ 指针，大小固定（8 字节）
	// Next Node // ❌ 编译报错：结构体大小无限递归
}

// 文件路径: ~/code/webook-syntax/compose/main.go
package main

import "fmt"

// 被组合的组件
type Logger struct{}

func (l Logger) Log(msg string) { fmt.Println("log:", msg) }

// Service 组合了 Logger，可以直接调用 Log 方法
type Service struct {
	Logger // 匿名字段：组合
}

func (s *Service) DoWork() {
	s.Log("starting work") // 方法直达
	fmt.Println("working...")
}

func main() {
	s := &Service{}
	s.DoWork()
}

// 文件路径: ~/code/webook-syntax/compose/forms.go
package main

import "fmt"

// 准备素材
type Logger struct{ Prefix string }

func (l Logger) Log(msg string) { fmt.Println(l.Prefix, msg) }

type Retrier interface{ Retry() }

type consoleRetrier struct{}

func (consoleRetrier) Retry() { fmt.Println("retrying...") }

// 一个结构体可以同时组合：结构体、结构体指针、接口
type Service struct {
	Logger  // 形态一：结构体组合结构体（最常用，gorm.Model 就是这种）
	Retrier // 形态二：结构体组合接口（要赋具体实现）
}

func main() {
	s := Service{
		Logger:  Logger{Prefix: "[svc]"},
		Retrier: consoleRetrier{},
	}
	s.Log("starting") // 方法直达
	s.Retry()         // 直接调接口字段的方法
}

type MyInt int    // 衍生类型：全新类型，有独立方法集
type MyInt2 = int // 类型别名：只是换名字，本质还是 int

package main

import "fmt"

type MyInt int

// 给衍生类型加方法——这是 int 做不到的
func (m MyInt) IsEven() bool {
	return m%2 == 0
}

func main() {
	var a MyInt = 4
	fmt.Println(a.IsEven()) // true

	// var b int = a     // ❌ 编译报错：需要显式转换
	var b int = int(a) // ✅
	fmt.Println(b)
}

func MaxInt(nums []int) int { /* ... */ }
func MaxInt64(nums []int64) int64 { /* ... */ }
func MaxFloat64(nums []float64) float64 { /* ... */ }
// 每个类型抄一遍……

Max[int]([]int{1, 2, 3})     // 显式指定 T = int
Max([]int{1, 2, 3})          // 或者让编译器自己推断

// 文件路径: ~/code/webook-syntax/slice/number.go
// 说明：这个约束是 slice 包的一部分（slice/slice.go 的 Max 依赖它），
// 所以要放在 slice/ 目录下；和 generic/ 下的 demo 文件放一起会 package 冲突
package slice

// 泛型约束：用 ~ 表示"底层类型是该类型的都算"
type Number interface {
	~int | ~int8 | ~int16 | ~int32 | ~int64 |
		~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 |
		~float32 | ~float64
}

// 文件路径: ~/code/webook-syntax/generic/sum.go
package main

import "fmt"

type Number interface {
	~int | ~int64 | ~float64
}

// 泛型函数：求任意数字类型切片的和
func Sum[T Number](nums []T) T {
	var total T
	for _, n := range nums {
		total += n
	}
	return total
}

// 泛型结构体
type Stack[T any] struct {
	data []T
}

// 泛型方法：注意接收器要写成 Stack[T]
func (s *Stack[T]) Push(v T) {
	s.data = append(s.data, v)
}

func (s *Stack[T]) Pop() (T, bool) {
	var zero T
	if len(s.data) == 0 {
		return zero, false
	}
	v := s.data[len(s.data)-1]
	s.data = s.data[:len(s.data)-1]
	return v, true
}

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

	s := &Stack[string]{}
	s.Push("a")
	s.Push("b")
	v, _ := s.Pop()
	fmt.Println("弹出:", v)
}

// 文件路径: ~/code/webook-syntax/generic/stringer.go
package main

import "fmt"

// 普通接口做约束：T 必须实现了 String() 方法
type Stringer interface {
	String() string
}

// 方法里可以直接调用 T 的接口方法
func JoinAll[T Stringer](items []T, sep string) string {
	out := ""
	for i, it := range items {
		if i > 0 {
			out += sep
		}
		out += it.String() // 直接调用接口方法
	}
	return out
}

// 自定义类型实现 String()，就能用 JoinAll
type Role int

func (r Role) String() string {
	return []string{"admin", "member", "guest"}[r]
}

func main() {
	fmt.Println(JoinAll([]Role{0, 1, 2}, " | "))
}

// 文件路径: ~/code/webook-syntax/slice/slice.go
package slice

// Filter 过滤切片：保留满足条件的元素
func Filter[T any](src []T, f func(T) bool) []T {
	dst := make([]T, 0, len(src))
	for _, v := range src {
		if f(v) {
			dst = append(dst, v)
		}
	}
	return dst
}

// Map 转换切片：把每个元素映射成另一个值
func Map[S, D any](src []S, f func(S) D) []D {
	dst := make([]D, 0, len(src))
	for _, v := range src {
		dst = append(dst, f(v))
	}
	return dst
}

// Max 求最大值
func Max[T Number](nums []T) (T, bool) {
	var zero T
	if len(nums) == 0 {
		return zero, false
	}
	max := nums[0]
	for _, n := range nums[1:] {
		if n > max {
			max = n
		}
	}
	return max, true
}

// Insert 在指定位置插入元素
func Insert[T any](src []T, idx int, v T) []T {
	if idx < 0 || idx > len(src) {
		panic("index out of range")
	}
	dst := append(src, v)          // 先扩容一位
	copy(dst[idx+1:], dst[idx:])   // 把 idx 及之后的元素后移
	dst[idx] = v                   // 填入新值
	return dst
}

// Delete 删除指定下标元素
func Delete[T any](src []T, idx int) []T {
	if idx < 0 || idx >= len(src) {
		panic("index out of range")
	}
	return append(src[:idx], src[idx+1:]...) // 后续元素前移覆盖
}

// 文件路径: ~/code/webook-syntax/slice_lib_demo/main.go
// 注意：demo 必须放在 slice 包目录之外的独立目录（如 slice_lib_demo/），
// 否则会和 slice/slice.go 的 package slice 冲突
package main

import (
	"fmt"

	"github.com/yourname/webook-syntax/slice"
)

func main() {
	nums := []int{1, 2, 3, 4, 5}

	// 过滤出偶数
	evens := slice.Filter(nums, func(n int) bool { return n%2 == 0 })
	fmt.Println("偶数:", evens)

	// 每个元素平方
	squares := slice.Map(nums, func(n int) int { return n * n })
	fmt.Println("平方:", squares)

	// int 转 string
	strs := slice.Map(nums, func(n int) string { return fmt.Sprintf("#%d", n) })
	fmt.Println("转字符串:", strs)

	// 求最大值
	if m, ok := slice.Max(nums); ok {
		fmt.Println("最大值:", m)
	}
}

// 工作池：3 个 worker 消费同一个任务 channel
func main() {
    jobs := make(chan int, 100)
    for i := 0; i < 3; i++ {
        go func(id int) {        // 每个 worker 一个 goroutine
            for j := range jobs { // channel 关闭后循环自动退出
                _ = j            // 处理任务
            }
        }(i)
    }
    for i := 0; i < 100; i++ {
        jobs <- i
    }
    close(jobs) // 关闭后 worker 的 range 才会结束
}

select {
case v := <-ch:
    fmt.Println("拿到", v)
case <-time.After(2 * time.Second):
    fmt.Println("超时了")
}

mkdir -p ~/code/webook-syntax && cd ~/code/webook-syntax
go mod init github.com/yourname/webook-syntax

// 文件路径: ~/code/webook-syntax/main.go
package main

import "fmt"

func main() {
	fmt.Println("webook-syntax 启动")
}

go run .

// 文件路径: ~/code/webook-syntax/user.go
package main

import "time"

type User struct {
	ID        int64
	Name      string
	Email     string
	CreatedAt time.Time
}

// 指针接收器：方法内修改会生效
func (u *User) Rename(newName string) {
	u.Name = newName
}

// 值接收器：只读方法
func (u User) Nickname() string {
	runes := []rune(u.Name)
	if len(runes) == 0 {
		return "匿名用户"
	}
	return string(runes[:1]) + "同学"
}

// Go 没有构造函数，用 NewXXX 代替
func NewUser(id int64, name, email string) *User {
	return &User{
		ID:        id,
		Name:      name,
		Email:     email,
		CreatedAt: time.Now(),
	}
}

// 文件路径: ~/code/webook-syntax/main.go
package main

import "fmt"

func main() {
	u := NewUser(1, "大明", "daming@example.com")
	fmt.Println("昵称:", u.Nickname())

	u.Rename("小明")
	fmt.Println("改名后:", u.Name, "昵称:", u.Nickname())
}

// 文件路径: ~/code/webook-syntax/repository.go
package main

// 接口由"使用方"定义，只声明需要的最小方法集
type UserRepository interface {
	Save(u *User) error
	FindByID(id int64) (*User, error)
	FindByName(name string) ([]*User, error)
	List() []*User
}

// 文件路径: ~/code/webook-syntax/memory.go
package main

import (
	"fmt"
	"sync"
)

// MemoryUserRepository 是 UserRepository 的内存实现
// 没有 implements 关键字，方法集满足即可
type MemoryUserRepository struct {
	mu    sync.RWMutex          // 并发安全：读写锁
	byID  map[int64]*User       // 主键索引
	order []int64               // 维护插入顺序（map 遍历无序）
}

func NewMemoryUserRepository() *MemoryUserRepository {
	return &MemoryUserRepository{
		byID:  make(map[int64]*User), // 必须初始化！
		order: make([]int64, 0, 64),  // 预估容量
	}
}

func (r *MemoryUserRepository) Save(u *User) error {
	r.mu.Lock()
	defer r.mu.Unlock() // defer 保证一定解锁

	if _, exists := r.byID[u.ID]; !exists {
		r.order = append(r.order, u.ID) // 新用户才记顺序
	}
	r.byID[u.ID] = u
	return nil
}

func (r *MemoryUserRepository) FindByID(id int64) (*User, error) {
	r.mu.RLock()
	defer r.mu.RUnlock()

	u, ok := r.byID[id]
	if !ok {
		return nil, fmt.Errorf("user %d not found", id)
	}
	return u, nil
}

func (r *MemoryUserRepository) FindByName(name string) ([]*User, error) {
	r.mu.RLock()
	defer r.mu.RUnlock()

	result := make([]*User, 0, len(r.order))
	for _, id := range r.order { // 按插入顺序遍历，结果稳定
		if u := r.byID[id]; u.Name == name {
			result = append(result, u)
		}
	}
	return result, nil
}

func (r *MemoryUserRepository) List() []*User {
	r.mu.RLock()
	defer r.mu.RUnlock()

	result := make([]*User, 0, len(r.order))
	for _, id := range r.order {
		result = append(result, r.byID[id])
	}
	return result
}

// 文件路径: ~/code/webook-syntax/slicex/slice.go
package slicex

// Number 约束：所有数字类型
type Number interface {
	~int | ~int64 | ~float64
}

// Filter 保留满足条件的元素
func Filter[T any](src []T, f func(T) bool) []T {
	dst := make([]T, 0, len(src))
	for _, v := range src {
		if f(v) {
			dst = append(dst, v)
		}
	}
	return dst
}

// Map 把 []S 转换成 []D
func Map[S, D any](src []S, f func(S) D) []D {
	dst := make([]D, 0, len(src))
	for _, v := range src {
		dst = append(dst, f(v))
	}
	return dst
}

// Max 求最大值，空切片返回 (zero,false)
func Max[T Number](nums []T) (T, bool) {
	var zero T
	if len(nums) == 0 {
		return zero, false
	}
	max := nums[0]
	for _, n := range nums[1:] {
		if n > max {
			max = n
		}
	}
	return max, true
}

// 文件路径: ~/code/webook-syntax/main.go
package main

import (
	"fmt"

	"github.com/yourname/webook-syntax/slicex"
)

func main() {
	// 依赖接口，不依赖具体实现
	var repo UserRepository = NewMemoryUserRepository()

	// 存入几个用户
	users := []*User{
		NewUser(1, "大明", "daming@example.com"),
		NewUser(2, "小明", "xiaoming@example.com"),
		NewUser(3, "大明", "daming2@example.com"),
	}
	for _, u := range users {
		if err := repo.Save(u); err != nil {
			panic(err)
		}
	}

	// 1. 按 ID 查
	if u, err := repo.FindByID(2); err == nil {
		fmt.Println("按 ID 查:", u.Name)
	}

	// 2. 按名字查（同名多个）
	daming, _ := repo.FindByName("大明")
	fmt.Println("叫大明的有", len(daming), "个")

	// 3. 用泛型工具：提取所有 ID 并求最大值
	all := repo.List()
	ids := slicex.Map(all, func(u *User) int64 { return u.ID })
	if maxID, ok := slicex.Max(ids); ok {
		fmt.Println("最大 ID:", maxID)
	}

	// 4. 用泛型工具：过滤出 ID > 1 的用户
	bigIDs := slicex.Filter(ids, func(id int64) bool { return id > 1 })
	fmt.Println("ID > 1 的:", bigIDs)

	// 5. 查不存在的用户
	if _, err := repo.FindByID(999); err != nil {
		fmt.Println("错误处理:", err)
	}
}