Go 学习总结：核心知识体系回顾

package main

import "fmt"

// 1. 定义 P 主结构体：名字与应援色两个字段
type Producer struct {
	Name  string
	Color string
}

// 2. 值接收者方法：只读不改，返回自我介绍
func (p Producer) Introduce() string {
	return "我是 P 主 " + p.Name + "，应援色是 " + p.Color
}

func main() {
	// 3. 短变量声明创建实例；未赋值的 Color 自动为零值空串
	p := Producer{Name: "星轨"}
	fmt.Println(p.Introduce())
}

package main

import "fmt"

func main() {
	// 1. 切片收集歌单，append 容量不足时自动扩容
	playlist := []string{"星屑", "回声"}
	playlist = append(playlist, "极光")

	// 2. 映射统计播放量：键不存在时取零值 0，可直接累加
	plays := map[string]int{}
	for _, song := range playlist {
		plays[song] += 100
	}

	// 3. 遍历映射的顺序随机，业务逻辑绝不能依赖它
	for song, n := range plays {
		fmt.Printf("%s 播放 %d 次\n", song, n)
	}
}

package main

import (
	"errors"
	"fmt"
)

// 1. 定义哨兵错误：查询的歌曲不存在
var errSongNotFound = errors.New("歌曲不存在")

// 2. 多返回值：结果与错误并列给出，签名即契约
func findSong(id int) (string, error) {
	if id != 1 {
		return "", fmt.Errorf("查询失败: %w", errSongNotFound)
	}
	return "星屑", nil
}

func main() {
	// 3. 调用方必须显式处理错误，编译器不做任何兜底
	name, err := findSong(2)
	if err != nil {
		fmt.Println("出错了:", errors.Is(err, errSongNotFound)) // true
		return
	}
	fmt.Println("找到歌曲:", name)
}

package main

import "fmt"

// 1. 定义歌姬接口：能唱歌、能报应援色
type Singer interface {
	Sing(song string) string
	Color() string
}

// 2. 虚拟歌姬结构体隐式实现接口，无需 implements 声明
type VirtualSinger struct{ Name string }

func (s VirtualSinger) Sing(song string) string { return s.Name + " 演唱《" + song + "》" }
func (s VirtualSinger) Color() string           { return "星空蓝" }

func main() {
	// 3. 面向接口编程：变量类型是 Singer，任何实现者都能登台
	var s Singer = VirtualSinger{Name: "初霜"}
	fmt.Println(s.Sing("极光"), "应援色", s.Color())
}

package main

import (
	"cmp"
	"fmt"
)

// 1. 约束 cmp.Ordered：类型参数 T 必须支持大小比较
// 2. 泛型函数：在任意可比较的列表中找最大值
func top[T cmp.Ordered](list []T) T {
	max := list[0]
	for _, v := range list[1:] {
		if v > max {
			max = v
		}
	}
	return max
}

func main() {
	// 3. 同一函数适配不同类型：找人气最高的票数与歌名
	fmt.Println(top([]int{520, 1314, 999}))          // 1314
	fmt.Println(top([]string{"星屑", "极光", "回声"})) // 极光
}

package main

import "fmt"

func main() {
	// 1. 带缓冲的 channel 汇总三场演唱会的售票结果
	results := make(chan int, 3)

	// 2. go 关键字并发执行匿名函数，i 作为参数传入避免共享循环变量
	for i := 1; i <= 3; i++ {
		go func(id int) {
			results <- id * 1000 // 模拟每场售出 1000*id 张票
		}(i)
	}

	// 3. 主 goroutine 收集结果，channel 收发天然同步，无需加锁
	total := 0
	for i := 0; i < 3; i++ {
		total += <-results
	}
	fmt.Println("三场演唱会共售票", total)
}

package main

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

func main() {
	// 1. 创建 2 秒超时的 context，控制演唱会直播推流
	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
	defer cancel() // 及时释放资源，防止 context 泄漏

	// 2. 模拟推流 goroutine：3 秒后才产出画面帧
	stream := make(chan string)
	go func() {
		time.Sleep(3 * time.Second)
		stream <- "歌姬画面"
	}()

	// 3. select 同时监听数据与超时，谁先就绪走谁
	select {
	case frame := <-stream:
		fmt.Println("收到", frame)
	case <-ctx.Done():
		fmt.Println("推流超时:", ctx.Err()) // 本例走这条分支
	}
}

package main

import "fmt"

// 1. recover 必须写在 defer 函数里，否则无法捕获 panic
func safeStage() {
	defer func() {
		if r := recover(); r != nil {
			fmt.Println("舞台事故已处理:", r)
		}
	}()
	panic("歌姬设备故障")
}

func main() {
	// 2. defer 按后进先出顺序执行：先注册的后执行
	defer fmt.Println("1. 清扫舞台")
	defer fmt.Println("2. 关闭灯光")
	safeStage()
	fmt.Println("3. 演出继续")
}

package stage

import "testing"

// 1. 被测函数：根据点赞与转发计算歌曲应援指数
func SupportIndex(likes, shares int) int {
	return likes*2 + shares*3
}

// 2. 表格驱动测试：用例是数据，循环逐行验证
func TestSupportIndex(t *testing.T) {
	cases := []struct {
		name          string
		likes, shares int
		want          int
	}{
		{"只有点赞", 10, 0, 20},
		{"只有转发", 0, 5, 15},
		{"混合计入", 1, 1, 5},
	}
	for _, c := range cases {
		if got := SupportIndex(c.likes, c.shares); got != c.want {
			t.Errorf("%s: got %d, want %d", c.name, got, c.want)
		}
	}
}

// 错误：三个 goroutine 打印的可能全是 3
for i := 0; i < 3; i++ {
    go func() { fmt.Println(i) }()
}

// 修正：把变量作为参数传入，形成每次迭代独立的副本
for i := 0; i < 3; i++ {
    go func(id int) { fmt.Println(id) }(i)
}

// 错误：s2 与 s1 共享底层数组，append 悄悄覆盖了 s1 的第三个元素
s1 := []string{"星屑", "回声", "极光"}
s2 := s1[:2]
s2 = append(s2, "夜航")
fmt.Println(s1) // [星屑 回声 夜航]

// 修正：完整切片表达式把容量限制为 2，append 必然新开数组
s2 := s1[:2:2]
s2 = append(s2, "夜航")

// 错误：返回了类型为 *VirtualSinger 的 nil，接口本身不等于 nil
func getSinger() Singer {
    var p *VirtualSinger
    return p
}
fmt.Println(getSinger() == nil) // false

// 修正：判空后显式返回真正的 nil 接口
func getSinger() Singer {
    var p *VirtualSinger
    if p == nil {
        return nil
    }
    return p
}

// 错误：重复 close 触发 panic: close of closed channel
ch := make(chan int)
close(ch)
close(ch)

// 修正：由唯一的发送出口负责关闭，用 defer 保证恰好一次
ch := make(chan int)
go func() {
    defer close(ch)
    ch <- 1
}()
fmt.Println(<-ch)

// 错误：并发写 map，运行时抛 fatal error: concurrent map writes
plays := map[string]int{}
for i := 0; i < 10; i++ {
    go func() { plays["星屑"]++ }()
}

// 修正：用互斥锁保护，或改用分片映射、sync.Map
var mu sync.Mutex
plays := map[string]int{}
for i := 0; i < 10; i++ {
    go func() {
        mu.Lock()
        defer mu.Unlock()
        plays["星屑"]++
    }()
}

// 错误：main 先退出，这行输出大概率永远看不到
func main() {
    go fmt.Println("这段话大概率不会出现")
}

// 修正：用 channel 或 sync.WaitGroup 等待子任务完成
func main() {
    done := make(chan struct{})
    go func() {
        fmt.Println("这次一定执行")
        close(done)
    }()
    <-done
}