package main // 当前属于的包，和文件名无必然关系

import "fmt" // format库

// 默认找到 main 函数执行，只能有一个 main 函数
func main(){
    // 调用 fmt 包中的 Println() 函数
    fmt.Println("Hello, World")
}

// 声明变量的几种方式
// 1. 全写
var name string = "Alice"
var age int = 30
var isActive bool

// 2. 直接初始化 自动识别类型
var name = "Alice"

// 3. 使用`:=`（常用）
name := "Alice"
age := 30



// 多变量声明
// 1. 标注类型
var c, python ,java bool // type 放多个变量的末尾
var x, y int = 1, 2 

// 2. 直接初始化 自动识别类型
var rust, golang, javascript  = true, false, "no!"
// If an initializer is present, the type can be omitted(省略); the variable will take the type of the initializer.

// 3. 使用 := 与 , 的形式
a, b := 10, 20

// 4. 块式批量声明
var (
	ToBe   bool       = false
	MaxInt uint64     = 1<<64 - 1
	z      complex128 = cmplx.Sqrt(-5 + 12i)
)


// 常量（只读）
// 1. 标注类型
const PI float64 = 3.14159
// 2. 直接初始化 自动识别类型
const PI = 3.14159
// 3. 块式批量声明
const (
    STATUSOK = 200
    STATUSNOTFOUND = 404
)

// iota 常量生成器（Go 特有）
const (
    SONDAY = iota  // 0
    MONDAY         // 1
    TUESDAY        // 2
)

// 基本类型
var (
    num     int
    decimal float64
    flag    bool
    text    string
)

package main

import (
    "fmt"
    "strings"
)

func main(){
    s := "hello, world"
    // 获取长度
    fmt.Println(len(s)) // len() 是内置函数，不需要导包
    
    // 转成大写(需要使用到strings库)
    fmt.Println(strings.ToUpper(s))
    
    fmt.Println(strings.Contains(s, "world"))
    
    fmt.Println(strings.Split(s, ","))
    
    // 把hello替换成你好
    fmt.Println(strings.ReplaceAll(s,"hello", "你好"))
    
}

// 数组
package main

import "fmt"

func main() {
    // 1. 先声明、再赋值
    // var arr [length]type
    var arr [3]int
    var a [2]string
    a[0] = "Hello"
    a[1] = "World"
    fmt.Println(a[0], a[1])// Hello World
    fmt.Println(a)		   // [Hello World]
    fmt.Println(len(a))	   // 2

    // 2. 定义的时候直接初始化（指定长度）
    primes := [6]int{2, 3, 5, 7, 11, 13}
    fmt.Println(primes)		// [2 3 5 7 11 13]
    
    // 3. 定义的时候直接初始化（不指定长度）【注意与下文切片的语法作区分】
    arr2 := [...]int{1, 2, 3, 4} // 长度依然确定，为4
    
    // 数组的遍历：
    for i:=0; i<len(primes);   i++ {
        fmt.Println(primes[i])
    }
    for index, value := range primes {
        fmt.Println(index, value)
    }
}

arr1 := [3]bool{true, true, false} // 创建的是数组
arr2 := []bool{true, true, false}  // 创建的是切片

// 切片

package main

import "fmt"

func main() {
    // 定义切片
  	// 1. 声明切片，后初始化
  	var slice []int // 此时 slice == nil
  	slice = make([]int, 3)
  	 
    // 2. 声明并初始化
    slice := []int{1, 2, 3}

    primes := [6]int{2, 3, 5, 7, 11, 13}

    // 截取切片
    // 通过指定上界和下界来截取切片：a[low:high]
    // 省略上界或下界时，使用的是默认值。下界的默认值是 0，上界的默认值是该切片的长度
    var s []int = primes[1:4] // 左闭右开
    fmt.Println(s) // [3 5 7]
}

package main

import "fmt"

func main() {
	s := []int{2, 3, 5, 7, 11, 13} 
	printSlice(s) // len=6 cap=6 [2 3 5 7 11 13]

  	// s[x:y]表示截取出下标 x ~ y-1 的元素
	// Slice the slice to give it zero length.
	s = s[:0]
	printSlice(s) // len=0 cap=6 []

	// Extend its length.
	s = s[:4]
	printSlice(s) // len=4 cap=6 [2 3 5 7]

	// Drop its first two values.
	s = s[2:]
	printSlice(s) // len=2 cap=4 [5 7]
}

func printSlice(s []int) {
	fmt.Printf("len=%d cap=%d %v\n", len(s), cap(s), s)
}

package main

import "fmt"

type Vertex struct {
	Lat, Long float64
}
// 1. 直接声明（var m map[KeyType]ValueType）
var m map[string]int		// 无法直接使用，需要用 make 开辟空间才能用
m = make(map[string]int, 10)
m["go"] = 1
m["java"] = 2

// 2. 使用 make 声明，然后可以直接赋值
m1 = make(map[int]string)
m1[1] = "java"
m1[2] = "go"
m2 = make(map[string]Vertex)
m2["Bell Labs"] = Vertex{
  40.68433, -74.39967,
}

// 3. 声明的同时完成初始化
m3 := map[string]string {
  "one": "php",
  "two": "go",
  "three": "Java"
}
m4 = map[string]Vertex{
	"Bell Labs": {40.68433, -74.39967},// Vertex 这里只表示类型名，可以省略（不省略的写法："Bell Labs": Vertex{40.68433, -74.39967}）
	"Google":    {37.42202, -122.08408},
}

// 遍历
for key, value := range m1 {
  fmt.Println("key= ", key)
  fmt.Println("value= ", value)
}

// 删除
delete(cityMap, "China")

// 修改
m["go"] = 0

// 获取 value
elem := m["go"]

// 可以通过双返回值赋值语句 elem, ok := m[key] 来检查 Map 中是否存在某个键
elem1, ok := m["Java"] // 如果存在这个 key，ok 为 true，否则为 flase
// 如果不存在这个 key，elem1 就是当前类型的零值（int 里面就是 0）

func WordCount(s string) map[string]int {
    counts := make(map[string]int)
    for _, word := range strings.Fields(s) {
        counts[word]++
    }
    return counts
}

var p *int

i := 42
p = &i			// &运算符返回其操作数（变量）的内存地址，从而生成一个指针。

fmt.Println(*p) // read i through the pointer p
*p = 21         // set i through the pointer p

package main

import "fmt"

func main() {
	i, j := 42, 2701

	p := &i         // point to i
	fmt.Println(*p) // read i through the pointer
	*p = 21         // set i through the pointer
	fmt.Println(i)  // see the new value of i

	p = &j         // point to j
	*p = *p / 37   // divide j through the pointer
	fmt.Println(j) // see the new value of j
}

package main

import (
	"fmt"
	"math"
)

func compute(fn func(float64, float64) float64) float64 {
	return fn(3, 4)
}

func main() {
	hypot := func(x, y float64) float64 {
		return math.Sqrt(x*x + y*y)
	}
	fmt.Println(hypot(5, 12)) //13

	fmt.Println(compute(hypot)) // 5
	fmt.Println(compute(math.Pow)) // 81
}

type 新名字 底层类型

// 基于内置类型创建有业务含义的新类型
type UserID int          // UserID 的底层类型是 int
type Score float64       // Score 的底层类型是 float64

// 基于复合类型创建
type StringSlice []string          // 底层类型是 []string
type UserMap map[int]string        // 底层类型是 map[int]string
type Handler func(w, r any) error  // 底层类型是函数签名

// 不用命名类型：看不出 int 代表什么
func GetUser(id int, age int) {}

// 用命名类型：一目了然
type UserID int
type Age int

func GetUser(id UserID, age Age) {}

var uid UserID = 1
var a Age = 25
uid = a           // ❌ 编译错误：cannot use a (type Age) as type UserID
uid = UserID(a)   // ✅ 显式转换后可以（底层类型相同）

type Celsius float64

// Celsius 就有了自己的方法，就像 Java 中类的实例方法
func (c Celsius) String() string {
    return fmt.Sprintf("%.1f°C", c)
}

func main() {
    t := Celsius(36.5)
    fmt.Println(t.String()) // "36.5°C"
}

type MyInt int     // 命名类型：MyInt 和 int 是不同类型，需要显式转换
type MyInt = int   // 类型别名：MyInt 就是 int 的另一个名字，可以互换

type Count int

var c Count = 10
var i int = int(c)     // Count → int（显式转换）
var c2 Count = Count(5) // int → Count（显式转换）

// 底层类型相同但命名不同的两个类型
type Apples int
type Oranges int
var a Apples = 5
var o Oranges = Oranges(a) // 允许直接转换

x, n := 2, 3
// go里面条件表达式不需要用括号包裹
if v := math.Pow(x, n); v < lim {
    return v
}
// go允许在条件表达式之前定义局部变量(if 语句也可以在条件判断前先执行一条简短语句。语句中声明的局部变量 作用域只到这个 if 语句结束)


fmt.Printf(v);// 这句会引发报错



if score := getScore(); score >= 60 {
    fmt.Println("及格")
} else {
    fmt.Println("不及格")
}
// score 的作用域仅限于 if-else 块


// 在 `if` 的简短语句中声明的变量，在任何对应的 `else` 代码块中也可以使用
if v := math.Pow(x, n); v < lim {
    fmt.Printf(v)
} else {
    fmt.Printf("%g >= %g\n", v, lim)
}

// for 循环（三种形式）
for i := 0; i < 10; i++ {// 传统循环
    fmt.Println(i)
};

// range 遍历
for i, v := range slice {
    fmt.Println(i, v)
}
for k, v := range map {
    fmt.Println(k, v)
}

// Go 里面的 for 关键字能直接起到 while 的作用（只有一个条件表达式的时候）
for i < 10 {
    
}                    


//无限循环
for {
    
}

// switch（自动 break）
switch day {
case "Mon", "Tue":  // 多条件
    fmt.Println("工作日")
case "Sat", "Sun":
    fmt.Println("周末")
default:
    fmt.Println("其他")
}

// 类型选择（switch 特殊用法）
switch v := interfaceValue.(type) {
case int:
    fmt.Println("整数")
case string:
    fmt.Println("字符串")
}

import (
	"fmt"
	"time"
)

func main() {
	t := time.Now()
    // switch 不加条件表达式相当于 switch true.
	switch {
	case t.Hour() < 12:
		fmt.Println("Good morning!")
	case t.Hour() < 17:
		fmt.Println("Good afternoon.")
	default:
		fmt.Println("Good evening.")
	}
}

import "strings"

s := "hello, world"

// 包含判断
strings.Contains(s, "world")       // true
strings.HasPrefix(s, "hello")      // true
strings.HasSuffix(s, "world")      // true

// 大小写转换
strings.ToUpper(s)                  // "HELLO, WORLD"
strings.ToLower(s)                  // "hello, world"

// 分割与拼接
strings.Split("a,b,c", ",")        // ["a" "b" "c"]
strings.Join([]string{"a", "b"}, "-") // "a-b"

// 替换
strings.ReplaceAll(s, "hello", "你好") // "你好, world"
strings.Replace(s, "l", "L", 2)       // "heLLo, world" (替换前2个)

// 去除空白
strings.TrimSpace("  hello  ")     // "hello"
strings.Trim("!!!hello!!!", "!")   // "hello"

// 统计与查找
strings.Count(s, "l")              // 3
strings.Index(s, "world")          // 7

import "strconv"

// 字符串 → 数值
i, err := strconv.Atoi("123")       // i=123
i64, _ := strconv.ParseInt("FF", 16, 64) // 十六进制解析, i64=255
f, _ := strconv.ParseFloat("3.14", 64)   // f=3.14
b, _ := strconv.ParseBool("true")        // b=true

// 数值 → 字符串
s := strconv.Itoa(456)              // "456"
s := strconv.FormatInt(255, 16)     // "ff"
s := strconv.FormatFloat(3.14, 'f', 2, 64) // "3.14"
s := strconv.FormatBool(true)       // "true"

import "fmt"

name, age := "Alice", 30

// 打印
fmt.Print("hello")                  // 不换行
fmt.Println("hello")                // 换行
fmt.Printf("name=%s, age=%d\n", name, age)

// 格式化字符串（不打印，返回字符串）
s := fmt.Sprintf("name=%s, age=%d", name, age)

// 常用占位符
// %v  默认格式，万能占位符  →  "Alice" / 30 / [1 2 3]
// %+v 打印结构体时带字段名   →  {Name:Alice Age:30}
// %#v Go语法表示             →  main.Person{Name:"Alice", Age:30}
// %T  打印类型              →  string / int
// %d  整数                  →  30
// %s  字符串                →  "Alice"
// %f  浮点数                →  3.140000
// %.2f 保留两位小数          →  3.14
// %t  布尔                  →  true
// %p  指针地址              →  0xc000012345

import "time"

now := time.Now()                   // 当前时间
year, month, day := now.Date()      // 年/月/日
hour, min, sec := now.Clock()       // 时/分/秒

// 格式化（Go 使用特定的参考时间：2006-01-02 15:04:05）
now.Format("2006-01-02 15:04:05")   // "2026-07-03 20:00:00"
now.Format("2006/01/02")            // "2026/07/03"
now.Format("15:04")                 // "20:00"

// 解析
t, _ := time.Parse("2006-01-02", "2026-07-03")

// 时间计算
t1 := time.Now()
t2 := t1.Add(2 * time.Hour)         // 两小时后
dur := t2.Sub(t1)                   // 2h0m0s

// 定时器
timer := time.NewTimer(3 * time.Second)
<-timer.C                           // 3 秒后收到信号

ticker := time.NewTicker(1 * time.Second)  // 每秒触发
for t := range ticker.C {
    fmt.Println(t)
}

import "math"

math.Abs(-5)            // 5
math.Max(3, 7)          // 7
math.Min(3, 7)          // 3
math.Pow(2, 10)         // 1024
math.Sqrt(16)           // 4
math.Ceil(3.14)         // 4（向上取整）
math.Floor(3.14)        // 3（向下取整）
math.Round(3.5)         // 4（四舍五入）

math.Pi                 // 3.141592653589793...

import "encoding/json"

type Person struct {
    Name string `json:"name"`   // 用字段标签控制 JSON 键名
    Age  int    `json:"age"`
}

// 结构体 → JSON（序列化）
p := Person{Name: "Alice", Age: 30}
jsonBytes, _ := json.Marshal(p)         // {"name":"Alice","age":30}
jsonStr, _ := json.MarshalIndent(p, "", "  ") // 带缩进

// JSON → 结构体（反序列化）
jsonStr := `{"name":"Bob","age":25}`
var p2 Person
json.Unmarshal([]byte(jsonStr), &p2)    // Person{Name:"Bob", Age:25}

// 未知结构的 JSON → map
var result map[string]interface{}
json.Unmarshal([]byte(jsonStr), &result)

import "os"

// 文件操作
data, err := os.ReadFile("data.txt")        // 一次性读取整个文件
os.WriteFile("output.txt", []byte("hello"), 0644) // 写入文件

// 文件打开（精细控制）
file, err := os.Open("data.txt")            // 只读打开
defer file.Close()

// 环境变量
home := os.Getenv("HOME")
os.Setenv("KEY", "value")

// 命令行参数
args := os.Args   // 程序启动参数，args[0] 是程序名

import "sort"

// 基础类型排序
nums := []int{3, 1, 4, 1, 5}
sort.Ints(nums)                         // [1 1 3 4 5]
sort.Sort(sort.Reverse(sort.IntSlice(nums))) // 降序

strs := []string{"c", "a", "b"}
sort.Strings(strs)                      // ["a" "b" "c"]

// 自定义排序
type Person struct { Name string; Age int }
people := []Person{{"Bob", 30}, {"Alice", 25}}
sort.Slice(people, func(i, j int) bool {
    return people[i].Age < people[j].Age  // 按年龄升序
})

import (
    "errors"
    "fmt"
)

err1 := errors.New("something went wrong")
err2 := fmt.Errorf("读取文件失败: %s", filename)

// Go 1.13+ 错误包装
err3 := fmt.Errorf("处理失败: %w", err1)
errors.Is(err3, err1)       // true — 判断是否包含该错误
errors.Unwrap(err3)         // err1 — 解包取原始错误

// Java
public class Main {
    public static void main(String[] args) {
        int i = 0;
        while (i < 5) {
            if (i % 2 == 0) {
                System.out.println("Even: " + i);
            }
            i++;
        }
    }
}
// Go
package main

import "fmt"

func main() {
    i := 0
    for i < 5 {
        if i % 2 == 0 {
            fmt.Println("Even:", i)
        }
        i++
    }
    
    // Go 特有的 if 初始化
    if x := 10; x > 5 {
        fmt.Println("x is large")
    }
    // 注意：x 的作用域仅限于 if 块内
}

// 1. 基础函数示例
func Add(a int, b int) int{
    return a + b
}
// 相同类型入参的简化写法：
func Add(a, b int) int {
    return a + b
}

// 2. 多返回值函数示例（Go 特色：函数可以有任意数量的返回值）
func swap(x, y string) (string, string){
    return y, x;
}
func Divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, errors.New("除数不能为零")
    }
    return a / b, nil
}

// 允许命名返回值
func GetInfo() (name string, age int) {
    name = "Alice"
    age = 30
    return  // 自动返回和返回值命名匹配的变量，可读性差，不推荐在长代码块函数里面yong（“A return statement without arguments returns the named return values. This is known as a "naked" return.“）
    
}

// 可变参数：能动态接收多个参数
func Sum(nums ...int) int {
    total := 0
    for _, val := range nums {
        total += val
    }
    return total
}
// 调用：Sum(1, 2, 3) 或 Sum(slice...)

// 1. 单行导入
import "fmt"
import "os"

// 2. 分组导入（推荐）
import (
    "fmt"
    "os"
)

// 3. 别名导入 — 解决包名冲突，或简化长包名
import (
    myfmt "mylib/fmt"                     // 自定义别名
    cm "github.com/easierway/concurrent_map"
)

// 4. 匿名导入 — 只执行 init()，不直接使用包内函数
import _ "github.com/lib/pq"             // 常用于注册数据库驱动、插件等

// 5. 点导入 — 将包内所有公开符号导入当前命名空间（不推荐，可读性差）
import . "fmt"                           // 之后可直接写 Println() 而非 fmt.Println()

package main

import "fmt"

// init 函数：无参数，无返回值
func init() {
    fmt.Println("第一个 init")
}

func init() {
    fmt.Println("第二个 init")
}

func main() {
    fmt.Println("main 函数")
}

// 输出：
// 第一个 init
// 第二个 init
// main 函数

┌─────────────────────────────────────────────────┐
│  同一文件内：按 init() 声明顺序依次执行            │
│  同一包内：按 .go 文件名排序，依次执行各文件的 init │
│  跨包依赖：被导入的包的 init 先于当前包的 init      │
│  main 包的 init 执行完后，才执行 main() 函数       │
└─────────────────────────────────────────────────┘

// ====== db/driver.go ======
package db

import "fmt"

func init() {
    fmt.Println("db/driver: init")
}

// ====== db/connection.go ======
package db

import "fmt"

func init() {
    fmt.Println("db/connection: init")
}

// ====== service/user.go ======
package service

import (
    "fmt"
    "myapp/db"            // service 依赖 db
)

func init() {
    fmt.Println("service/user: init")
}

// ====== main.go ======
package main

import (
    "fmt"
    "myapp/db"
    "myapp/service"
)

func init() {
    fmt.Println("main: init")
}

func main() {
    fmt.Println("main() 执行")
}

// 输出顺序：
// db/driver: init          ← 最底层的依赖先初始化
// db/connection: init      ← 同包内按文件名排序
// service/user: init       ← 依赖 db 的 service 后初始化
// main: init               ← main 包的 init 最后
// main() 执行              ← 最后执行 main()

// 1. 定义并立即执行匿名函数（最常用）
func() {
    fmt.Println("Hello")
}() // ← 末尾的 () 表示立即调用

// 带参数 + 返回值
result := func(a, b int) int {
    return a + b
}(3, 4) // result = 7

// 2. 赋值给变量，后续调用(相当于正常定义了一个函数)
add := func(a, b int) int {
    return a + b
}
fmt.Println(add(1, 2)) // 3
fmt.Println(add(5, 6)) // 11

// 3. 作为另一个函数的参数（回调模式）
nums := []int{1, 2, 3, 4}
// sort.Slice 接收一个匿名函数来决定排序规则
sort.Slice(nums, func(i, j int) bool {
    return nums[i] > nums[j] // 降序
})

// 4. 作为函数的返回值（闭包，见下文）

// 闭包经典示例：累加器
func adder(initial int) func(int) int {
    sum := initial                         // sum 属于 adder 的局部变量
    return func(x int) int {               // 返回的匿名函数"捕获"了 sum
        sum += x                           // 修改的是同一个 sum
        return sum
    }
}

func main() {
    f := adder(0)   // 创建一个闭包，它有自己的 sum，初始值 = 0
    fmt.Println(f(1))  // sum = 0 + 1 = 1
    fmt.Println(f(2))  // sum = 1 + 2 = 3
    fmt.Println(f(3))  // sum = 3 + 3 = 6

    g := adder(100) // 再创建一个闭包，它有自己的 sum，初始值 = 100
    fmt.Println(g(1))  // sum = 100 + 1 = 101
    fmt.Println(g(2))  // sum = 101 + 2 = 103

    // f 和 g 的 sum 互不影响 — 每次调用 adder() 都会在堆上分配一个全新的 sum
    fmt.Println(f(1))  // sum = 6 + 1 = 7   （f 的 sum 还是 6）
}

adder() 被调用
  │
  ├─ 在堆上分配 sum := 0        ← sum 逃逸到堆（因为返回的闭包引用了它）
  │
  └─ 返回匿名函数 func(x int) int { sum += x; return sum }
       │                         ← 这个匿名函数"绑定"了堆上的 sum
       │
       ▼
  每次调用这个返回的函数，都是在读写同一个 sum

// 返回一个"加固定值"的函数
func makeAdder(n int) func(int) int {
    return func(x int) int { return x + n }
}

// 返回一个过滤器：只保留 >= threshold 的值
func filterAbove(threshold int) func(int) bool {
    return func(x int) bool { return x >= threshold }
}

func main() {
    add5 := makeAdder(5)
    fmt.Println(add5(10)) // 15

    pass := filterAbove(60)
    scores := []int{55, 80, 45, 90, 60}
    for _, s := range scores {
        if pass(s) {
            fmt.Println("及格:", s) // 80, 90, 60
        }
    }
}

// 错误写法：所有闭包共享同一个循环变量 i
var funcs []func() int
for i := 0; i < 3; i++ {
    funcs = append(funcs, func() int {
        return i // 捕获的是变量 i 的引用，不是值！
    })
}
for _, f := range funcs {
    fmt.Println(f()) // 输出：3 3 3（不是 0 1 2）
}
// 原因：循环结束后 i=3，所有闭包读到的都是同一个 i

// 正确写法一：用局部变量"快照"当前值
for i := 0; i < 3; i++ {
    i := i                            // ← 重新声明一个同名新变量，作用域只在本次迭代
    funcs = append(funcs, func() int {
        return i                      // 捕获的是这次迭代独有的 i
    })
}
// 输出：0 1 2

// 正确写法二：通过参数传入
for i := 0; i < 3; i++ {
    funcs = append(funcs, func(n int) func() int {
        return func() int { return n }
    }(i)) // 立即执行外层函数，把 i 的值传给 n
}
// 输出：0 1 2

package main

import "fmt"

func main() {
	defer fmt.Print("world")

	fmt.Print("hello ")
}
// 输出：hello world

// Deferred function calls are pushed onto a stack. When a function returns, its deferred calls are executed in last-in-first-out order.
func readFile() error {
    file, err := os.Open("data.txt")
    if err != nil {
        return err
    }
    defer file.Close()  // 函数返回前自动执行
    
    // 多个 defer 按 LIFO 顺序执行(后进先出)
    defer fmt.Println("最后执行")
    defer fmt.Println("中间执行")
    // 输出顺序：中间执行 → 最后执行
    
    // 读取文件逻辑...
    return nil
}

// Java: 模拟多返回值通常需要创建 DTO 类或使用 Map
public Result divide(int a, int b) {
    if (b == 0) {
        throw new ArithmeticException("Divide by zero");
    }
    return new Result(a / b, null);
}
// 调用
try {
    Result r = divide(10, 2);
} catch (ArithmeticException e) {
    // 处理
}
// Go: 原生多返回值 + 显式错误处理
func divide(a, b int) (int, error) {
    if b == 0 {
        return 0, errors.New("divide by zero")
    }
    return a / b, nil
}

// 调用处：必须显式处理错误
result, err := divide(10, 2)
if err != nil {
    log.Fatal(err)
}

package main

import "fmt"

type Vertex struct {
    X int
    Y int
    age int
}

func main() {
  	// 1. 结构体的初始化
    fmt.Println(Vertex{1, 2, 3})// 输出{1 2 3}
    fmt.Println(Vertex{1, 2})// 报错：too few values in struct literal of type Vertex
  
  	vertex := Vertex{X:1, Y:2}
    fmt.Println(vertex)// 输出{1 2 0}
    // 可以使用 Name: 语法仅列出部分字段来初始化（而且属性的顺序无关紧要）
  	  
  
    // 2. 结构体的范围访问
    v := Vertex{1, 2, 3}
    v.age = 10
    ftm.Println(v.age) // 输出10
    
    
  	// 指向该结构体的指针也可以直接访问它的属性值(* 可以省略)
    p := &v
    p.age = 12 
    // "To access the field X of a struct when we have the struct pointer p we could write (*p).X. However, that notation is cumbersome, so the language permits us instead to write just p.X, without the explicit dereference."
    
  	fmt.Println(v.age) // 输出12
}

// 结构体的值传递和引用传递

type User struct {
    Name string
    Age  int
}

// 值传递：修改的是副本，不影响原变量
func renameByValue(u User, newName string) {
    u.Name = newName
}

// 引用传递：通过指针修改原变量
func renameByRef(u *User, newName string) {
    u.Name = newName
}

func main() {
    user := User{Name: "张三", Age: 25}

    // 值传递 — 原结构体不会被修改
    renameByValue(user, "李四")
    fmt.Println(user.Name) // 输出：张三（未改变）

    // 引用传递（传指针）— 原结构体被修改
    renameByRef(&user, "李四")
    fmt.Println(user.Name) // 输出：李四（已改变）

    // 对比：值传递 vs 引用传递对性能的影响
    // 值传递 = 复制整个结构体，结构体越大开销越大
    // 引用传递 = 只传一个 8 字节的指针地址，无论结构体多大，开销恒定
}

type User struct {
    ID       int    `json:"id" db:"user_id"`
    Name     string `json:"name" xml:"name"`
    Age      int    `json:"age"`
    Password string `json:"-"`                  // "-" 表示忽略该字段
    email    string `json:"email"`               // 小写字段不导出，json tag 无效
}

u := User{ID: 1, Name: "Alice", Age: 30}
data, _ := json.Marshal(u)
fmt.Println(string(data))  // {"id":1,"name":"Alice","age":30}（Password 被忽略，email 未导出）

type Person struct {
    FirstName string
    LastName  string
    Age       int
}

// 值接收（复制副本）—— 可以用于读操作，无法修改原始值【相当于值传递】
func (p Person) FullName() string {
    return p.FirstName + " " + p.LastName
}

// 指针接收（可修改原值）—— 需要修改结构体字段时使用【相当于引用传递】
func (p *Person) SetAge(newAge int) {
    p.Age = newAge
}

func (p *Person) Birthday() {
    p.Age++  // 指针接收者，可以直接修改原值
}

// 使用示例
func main() {
    p := Person{FirstName: "张", LastName: "三", Age: 25}

    // 值接收：p 和指向 p 的指针都可以调用
    fmt.Println(p.FullName())   // "张 三"
    ptr := &p
    fmt.Println(ptr.FullName()) // "张 三"（Go 自动解引用，等价于 (*ptr).FullName()）

    // 指针接收：只有可寻址的变量能调用
    p.SetAge(30)
    fmt.Println(p.Age)          // 30（原值已修改）

    p.Birthday()
    fmt.Println(p.Age)          // 31

    // ⚠️ 值接收者不会修改原值
    // 这里修改的只是副本，原 p 不变 — 详见上方「结构体的值传递和引用传递」
}

type Animal struct {
    Name string
}

func (a Animal) Speak() {
    fmt.Println("Animal speaks")
}

// 嵌入结构体（组合）—— Dog 获得了 Animal 的所有字段和方法
type Dog struct {
    Animal      // 匿名嵌入
    Breed string
}

func main() {
    d := Dog{Animal: Animal{Name: "旺财"}, Breed: "哈士奇"}

    // 1. 直接访问嵌入结构体的字段和方法（提升）
    fmt.Println(d.Name)    // "旺财"
    fmt.Println(d.Animal.Name) // "旺财"
    d.Speak()              // "Animal speaks"

    // 2. 方法重写 —— Dog 可以覆盖 Animal 的方法
    // func (d Dog) Speak() { fmt.Println(d.Name, "汪汪") }
    // d.Speak()  // 输出 "旺财 汪汪"（调用 Dog 自己的 Speak）
    // d.Animal.Speak()  // 仍可显式调用被嵌入类型的方法

    // 3. 多层级嵌入
    // type Puppy struct { Dog }   // Puppy 同时拥有 Animal 和 Dog 的字段/方法
}

type Reader interface { Read(p []byte) (n int, err error) }
type Writer interface { Write(p []byte) (n int, err error) }

// 如果 bufio.Reader 实现了 io.Reader，bufio.Writer 实现了 io.Writer
// 那么嵌入了两者的结构体自动同时实现这两个接口：
type ReadWriter struct {
    *bufio.Reader   // 提升 Read 方法 → 实现了 io.Reader
    *bufio.Writer   // 提升 Write 方法 → 实现了 io.Writer
}
// ReadWriter 自动实现了 io.Reader、io.Writer、io.ReadWriter 三个接口！

┌──────────────────────────────────┐
│  接口变量: var s Speaker         │
│  ┌────────────┬────────────────┐ │
│  │ 具体类型    │ 具体值          │ │
│  │ (concrete  │ (concrete      │ │
│  │  type)     │  value)        │ │
│  └────────────┴────────────────┘ │
└──────────────────────────────────┘

var s Speaker          // 静态类型=Speaker，具体类型=nil，具体值=nil
s = Dog{Name: "旺财"}  // 静态类型=Speaker，具体类型=Dog，具体值=Dog{Name:"旺财"}
s = Cat{}              // 静态类型=Speaker，具体类型=Cat，具体值=Cat{}

// 类型断言的本质：从接口中提取具体类型
dog, ok := s.(Dog)     // 检查 s 的具体类型是不是 Dog

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

// Dog 实现了 Speaker（隐式，无需写 "implements Speaker"）
type Dog struct{ Name string }
func (d Dog) Speak() string { return d.Name + ": 汪汪" }

// Cat 也实现了 Speaker
type Cat struct{}
func (c Cat) Speak() string { return "喵喵" }

func main() {
    // 多态：用接口类型接收不同的具体实现
    var s Speaker
    s = Dog{Name: "旺财"}
    fmt.Println(s.Speak())  // "旺财: 汪汪"
    s = Cat{}
    fmt.Println(s.Speak())  // "喵喵"
}

type Greeter interface { Greet() string }

type User struct{ Name string }

func (u User) Greet() string { return "Hi, " + u.Name }     // 值接收者

func main() {
    var g Greeter
    g = User{Name: "Alice"}  // 实现类实例的值可以
    g = &User{Name: "Bob"}   // 实现类实例的指针也可以（Go 会自动解引用）
}

func (u *User) SetName(name string) { u.Name = name }       // 指针接收者

func main() {
    var s Setter
    s = &User{Name: "Alice"}  // 实现类实例的指针可以
    s = User{Name: "Alice"}   // 实现类实例的值可以(会编译错误)
}

// Go 1.18+ 推荐用 any（ interface{} 的别名）
func PrintAny(v any) {
    fmt.Println(v)
}

PrintAny(42)            // int
PrintAny("hello")       // string
PrintAny(Dog{Name: "旺财"}) // struct

var v any = "hello"

// 类型断言（安全写法）
s, ok := v.(string) // 判断是否是 string 类型
if ok {
    fmt.Println("是字符串:", s)
}

i, ok := v.(int)
fmt.Println(i, ok)  // 0 false（断言失败返回零值和 false）

// 类型选择（配合 switch）
switch val := v.(type) { // 使用 .(type) 直接获取类型
    case int:
        fmt.Println("整数:", val)
    case string:
        fmt.Println("字符串:", val)
    case Dog:
        fmt.Println("狗叫:", val.Speak())
    default:
        fmt.Println("未知类型")
}

✅ 接受接口，返回结构体
✅ 接口要小（1-3 个方法最佳），按需定义
✅ 在使用方定义接口，而非实现方
❌ 避免大而全的接口（Java 式的 "AnimalInterface"）

// 好：在使用方定义需要的接口
func Shout(s Speaker) {
    fmt.Println(strings.ToUpper(s.Speak()))
}

// 差：在实现方预先定义巨型接口
type AnimalInterface interface {
    Speak() string; Eat(); Sleep(); Run(); ...
}

// 编译时断言：*RawMessage 必须实现 json.Marshaler 接口
var _ json.Marshaler = (*RawMessage)(nil)

// ===== 定义一个接口 =====
type Notifier interface {
    Notify(msg string) error
}

// ===== 具体实现：类型名小写，不公用 =====
type emailNotifier struct {
    address string
}

func (e *emailNotifier) Notify(msg string) error {
    // 发送邮件...
    fmt.Printf("向 %s 发送邮件：%s\n", e.address, msg)
    return nil
}

type smsNotifier struct {
    phone string
}

func (s *smsNotifier) Notify(msg string) error {
    // 发送短信...
    fmt.Printf("向 %s 发送短信：%s\n", s.phone, msg)
    return nil
}

// ===== 构造函数：返回接口，不暴露具体类型 =====
func NewEmailNotifier(address string) Notifier {
    return &emailNotifier{address: address} // 返回的是接口类型！
}

func NewSMSNotifier(phone string) Notifier {
    return &smsNotifier{phone: phone}
}

// 调用方只依赖 Notifier 接口，不关心底层是邮件还是短信
func SendAlert(n Notifier) {
    n.Notify("服务器负载过高！")
}

func main() {
    email := NewEmailNotifier("admin@example.com")
    sms := NewSMSNotifier("13800138000")

    SendAlert(email) // 底层发邮件，调用方不知道也不关心
    SendAlert(sms)   // 换成短信，调用方代码一行都不用改
}

import "reflect"

x := 42
t := reflect.TypeOf(x)    // reflect.Type  — 类型信息（相当于 Java 的 Class<?>）
v := reflect.ValueOf(x)   // reflect.Value — 值信息（可读可写）

fmt.Println(t.Kind())     // "int"（底层种类）
fmt.Println(v.Int())      // 42（获取具体值）
fmt.Println(v.Interface())// 42（还原为 interface{}）

type User struct {
    Name string `json:"name" db:"username"`
    Age  int    `json:"age"`
}

u := User{Name: "Alice", Age: 30}
t := reflect.TypeOf(u)
v := reflect.ValueOf(u)
for i := 0; i < t.NumField(); i++ {
    field := t.Field(i)
    fmt.Printf("字段: %s, 类型: %s, 值:, json tag: %s\n",
               field.Name, field.Type, v.Field(i).Interface(), field.Tag.Get("json"))
}
// 输出：
// 字段: Name, 类型: string, json tag: name
// 字段: Age, 类型: int, json tag: age

v := reflect.ValueOf(&u).Elem()    // 必须传指针 + Elem() 才能修改

nameField := v.FieldByName("Name")
if nameField.CanSet() {
    nameField.SetString("Bob")     // u.Name = "Bob"
}

ageField := v.FieldByName("Age")
ageField.SetInt(25)                // u.Age = 25

fmt.Println(u)  // {Bob 25}

type Calculator struct{}

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

func main() {
    c := Calculator{}
    v := reflect.ValueOf(c)
    method := v.MethodByName("Add")

    args := []reflect.Value{
        reflect.ValueOf(3),
        reflect.ValueOf(4),
    }
    results := method.Call(args)
    fmt.Println(results[0].Int())  // 7
}

public class Animal {
    private String name;
    
    public Animal(String name) {
        this.name = name;
    }
    
    public void Speak() {
        System.out.println("Animal speaks");
    }
}

public class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }

    @Override
    public void Speak() {
        System.out.println("Woof!");
    }
}

type Animal struct {
    Name string
}

func (a Animal) Speak() {
    fmt.Println("Animal speaks")
}

func NewAnimal(name string) *Animal {
    return &Animal{Name: name}
}

type Dog struct {
    Animal  // 嵌入
}

func (d Dog) Speak() {
    fmt.Println("Woof!")
}

type Speaker interface {
    Speak()
}
// var s Speaker = Dog{} // 合法，隐式实现

// error 是内置接口
type error interface {
    Error() string
}

// 标准库错误
errors.New("错误信息")
fmt.Errorf("格式化错误：%s", msg)

type TimeoutError struct {
    Operation string
    Duration  time.Duration
}

// 实现 error 接口
func (e *TimeoutError) Error() string {
    return fmt.Sprintf("操作 '%s' 超时：%v", e.Operation, e.Duration)
}

// 创建自定义错误
err := &TimeoutError{Operation: "DB.Query", Duration: 5 * time.Second}

// 基础错误检查
result, err := PerformOperation()
if err != nil {
    log.Printf("错误: %v", err)
    return
}

// 类型断言判断具体错误类型
if te, ok := err.(*TimeoutError); ok {
    log.Printf("超时操作：%s, 时长：%v", te.Operation, te.Duration)
}

// Go 1.13+ 推荐方式：errors.Is() 和 errors.As()
if errors.Is(err, os.ErrNotExist) {
    // 处理文件不存在
}

var te *TimeoutError
if errors.As(err, &te) {
    // 处理超时错误
}

// 包装错误，保留原始错误链
err := doSomething()
if err != nil {
    return fmt.Errorf("处理失败: %w", err)  // %w 保留原始错误
}

// 解包错误
originalErr := errors.Unwrap(wrappedErr)

// 抛出 panic（慎用）
panic("严重错误")

// 捕获 panic
func safeFunc() {
    defer func() {
        if r := recover(); r != nil {
            log.Printf("捕获 panic: %v", r)
        }
    }()
    // 可能 panic 的代码
}

// Java
public String readFile(String path) throws IOException {
    try {
        return Files.readString(Paths.get(path));
    } catch (FileNotFoundException e) {
        throw new CustomException("文件不存在", e);
    } catch (IOException e) {
        throw new CustomException("IO 错误", e);
    }
}
// Go
func readFile(path string) (string, error) {
    data, err := os.ReadFile(path)
    if err != nil {
        if errors.Is(err, os.ErrNotExist) {
            return "", fmt.Errorf("文件不存在：%w", err)
        }
        return "", fmt.Errorf("读取失败：%w", err)
    }
    return string(data), nil
}

$GOPATH/
├── src/          ← 所有源码（你的项目 + 第三方库）
│   ├── github.com/
│   │   └── gin-gonic/
│   │       └── gin/       ← go get 拉下来的库源码
│   └── myproject/         ← 你的项目
├── pkg/           ← 编译后的 .a 中间文件
└── bin/           ← go install 编译出的可执行文件

go get github.com/gin-gonic/gin   # 拉取最新代码到 $GOPATH/src/
go get -u github.com/gin-gonic/gin  # 更新到最新

GOPATH 时代                     Go Modules 时代
──────────────────────────────────────────────────
项目必须在 $GOPATH/src/      →  项目放在任意目录都行
依赖无版本，用最新 commit    →  语义化版本（v1.2.3）
所有项目共享一份依赖          →  每个项目独立管理依赖

// go.mod
module github.com/mycompany/myproject   // ← 模块路径（模块唯一标识，相当于 Maven 的 groupId:artifactId）

go 1.21                                  // ← 最低 Go 版本要求

require (
    github.com/gin-gonic/gin v1.9.0      // ← 直接依赖 + 版本号
    github.com/stretchr/testify v1.8.0
)

// 可选指令：
replace github.com/old/lib => github.com/new/lib v1.0.0   // 替换依赖源[相当于导入依赖时的重定向机制]（用于 fork 或本地开发）
exclude github.com/broken/lib v1.2.3                       // 排除某个版本
retract v1.0.0                                             // 声明撤回已发布的版本

github.com/gin-gonic/gin v1.9.0 h1:O3FBK4y9HhG9...= // 对‘github.com/gin-gonic/gin v1.9.0’下面所有文件做哈希
github.com/gin-gonic/gin v1.9.0/go.mod h1:x0K15p8H5... // 只对‘github.com/gin-gonic/gin v1.9.0’下面的 go.mod 文件做了哈希

场景：
  你的项目 → A v1.5.0
  你的项目 → B v1.2.0
  A v1.5.0 → B v1.8.0  ← A 需要更高版本的 B

MVS 结果：
  选 B v1.8.0（因为 A 要求 ≥ 1.8，1.2 不满足）

go get → proxy.golang.org → GitHub（原始仓库）
          ↑
     缓存 + 加速 + 防仓库删除

# 初始化模块（在项目根目录执行）【常用】
go mod init example.com/hello # 这里的"example.com/hello"新模块的唯一标识/路径【注意：如果你想发布这个 module，则它的唯一标识必须是一个可以被下载下来的路径(也就是它存放的代码仓库的路径)】

# 下载依赖(手动)
go get github.com/gin-gonic/gin          # 下载最新版本
go get github.com/gin-gonic/gin@v1.9.0   # 下载指定版本
go get -u github.com/gin-gonic/gin       # 升级到最新

# 以下这些命令会自动补充缺失的依赖
go build / go run / go test

# 整理依赖（添加缺失的，删除无用的）
go mod tidy

# 将依赖下载到本地缓存
go mod download

# 查看依赖树
go mod graph

# 查看"为什么依赖了这个包"
go mod why github.com/some/pkg

# 验证依赖完整性（比对 go.sum 的哈希）
go mod verify

# 查看当前模块的所有依赖列表
go list -m all

# 三个值：
go env -w GO111MODULE=on    # 强制启用 Go Modules（Go 1.16+ 默认）
go env -w GO111MODULE=off   # 强制回退 GOPATH 模式
go env -w GO111MODULE=auto  # 有 go.mod 就启用，否则用 GOPATH

# 查看当前代理
go env GOPROXY
# https://proxy.golang.org,direct

# 常见配置：
go env -w GOPROXY=https://goproxy.cn,direct           # 国内代理（七牛云），下载更快
go env -w GOPROXY=https://goproxy.io,direct            # 另一个国内代理
go env -w GOPROXY=direct                                # 不走代理，直接从源仓库拉
go env -w GOPROXY=off                                   # 禁止下载任何模块
go env -w GOPROXY=file://${GOPATH}/pkg/mod/cache/download,direct  # 优先用本地缓存

# 单个域名
go env -w GOPRIVATE=gitlab.mycompany.com

# 通配符匹配
go env -w GOPRIVATE=*.corp.com,*.internal.net

# 指定通配符后，这些模块会：
#   1. 不走 GOPROXY（直接连源仓库）
#   2. 不校验 GONOSUMDB（sum.golang.org 上没有私有模块的哈希）
#   3. 等同于同时设置了 GONOPROXY + GONOSUMDB + GONOSUMCHECK 为该模式

go env GOMODCACHE
# /Users/xxx/go/pkg/mod

# 修改缓存目录（比如磁盘空间不够）
go env -w GOMODCACHE=/data/go-mod-cache

# 查看所有 Go 环境变量
go env

# 查看单个
go env GOPROXY
go env GOPRIVATE

# 永久设置（写入 $HOME/.config/go/env，或 OS 特定路径）
go env -w GOPROXY=https://goproxy.cn,direct
go env -w GOPRIVATE=*.corp.com

# 仅在当前终端生效（临时覆盖）
export GOPROXY=direct

// mypkg/utils.go
package mypkg

func PublicFunc() {}    // 外部可访问（大写开头）
func privateFunc() {}   // 仅包内可用（小写开头）

❌ 错误示例：
A 包 import B 包
B 包 import A 包    ← 编译错误：import cycle not allowed

// Java: Maven pom.xml 声明依赖
// <dependency>
//   <groupId>com.google.code.gson</groupId>
//   <artifactId>gson</artifactId>
//   <version>2.10.1</version>
// </dependency>

import com.google.gson.Gson;

public class Main {
    public static void main(String[] args) {
        Gson gson = new Gson();
        String json = gson.toJson(new int[]{1, 2, 3});
        System.out.println(json);  // [1,2,3]
    }
}

// Go: go.mod 声明依赖
// module myapp
// go 1.21
// require github.com/gin-gonic/gin v1.9.0

package main

import "github.com/gin-gonic/gin"

func main() {
    r := gin.Default()
    r.GET("/ping", func(c *gin.Context) {
        c.JSON(200, gin.H{"message": "pong"})
    })
    r.Run()
}

   线程 A ──→ 共享变量 ←── 线程 B
              ↑ 锁保护 ↑

   协程 A ──→ channel ──→ 协程 B
              ↑ 数据通过管道传递，无需锁 ↑

func doWork(id int) {
    fmt.Println("worker", id)
}

func main() {
    go doWork(1)  // 启动一个 goroutine，不阻塞 main
    go doWork(2)  // 再启动一个

    time.Sleep(time.Second)  // 等待 goroutine 执行完（实际开发用 WaitGroup 或 channel）
}

goroutine A                    goroutine B
    │                              │
    │  ch <- data                  │  data := <-ch
    │  (发送数据到管道)              │  (从管道接收数据)
    │                              │
    └──────────▶  channel  ◀───────┘
                 (类型安全的数据管道)

// ===== 声明与创建 =====
var ch chan int             // 声明，此时 ch == nil（nil channel 读写都会永久阻塞！）
ch = make(chan int)         // 无缓冲 channel

ch := make(chan int, 3)     // 有缓冲 channel，容量 3

// ===== 发送与接收 =====
ch <- 42                    // 发送：把 42 放入 channel
value := <-ch               // 接收：从 channel 取出一个值
value, ok := <-ch           // 接收 + 检查：ok=false 表示 channel 已关闭且已空

// ===== 关闭 =====
close(ch)                   // 关闭 channel（发送方关闭，接收方检测）

// ===== 遍历 =====
for v := range ch {         // 不断从 channel 接收，直到 channel 被 close
    fmt.Println(v)
}

func main() {
    ch := make(chan int) // 无缓冲

    go func() {
        fmt.Println("准备接收...")
        v := <-ch                        // 阻塞，直到有人发送
        fmt.Println("收到:", v)
    }()

    time.Sleep(1 * time.Second)          // 等 goroutine 进入接收状态
    fmt.Println("发送 42...")
    ch <- 42                             // 有人接收了，发送成功
    fmt.Println("发送完成")
}

// 输出：
// 准备接收...
// 发送 42...
// 收到: 42
// 发送完成

func main() {
    ch := make(chan int, 2) // 容量 2 的缓冲

    ch <- 1   // 不阻塞，缓冲区: [1]
    ch <- 2   // 不阻塞，缓冲区: [1, 2]
    // ch <- 3 // 会阻塞！缓冲区满了，必须等有人取走一个

    fmt.Println(<-ch) // 1，缓冲区: [2]
    fmt.Println(<-ch) // 2，缓冲区: []
    // fmt.Println(<-ch) // 会阻塞！缓冲区空了，必须等有人发送
}

时间线（有缓冲 channel）：
  发送 1 → [1] → 不阻塞，直接返回
  发送 2 → [1,2] → 不阻塞，直接返回
  发送 3 → [1,2,?] → 缓冲区满，阻塞等待
                  → 接收方取走 1 → 3 写入成功 → [2,3]

// 只能发送
func producer(ch chan<- int) {
    for i := 0; i < 5; i++ {
        ch <- i
    }
    close(ch) // 发送方负责关闭
}

// 只能接收
func consumer(ch <-chan int) {
    for v := range ch {
        fmt.Println(v)
    }
    // ch <- 1  // 编译错误：cannot send to receive-only channel
}

func main() {
    ch := make(chan int, 3)
    go producer(ch) // 双向 channel 自动转为单向
    consumer(ch)
}

// 典型模式：生产者-消费者
func producer(ch chan<- int) {
    for i := 1; i <= 5; i++ {
        ch <- i
    }
    close(ch)  // ← 发送完毕，关闭 channel。消费者靠这个退出 range 循环
}

func main() {
    ch := make(chan int)
    go producer(ch)
    
    for v := range ch {  // channel 关闭且为空时，range 自动退出
        fmt.Println(v)
    }
    fmt.Println("接收完毕")
}

// 输出：1 2 3 4 5 接收完毕

func worker(id int, jobs <-chan int, results chan<- int) {
    for j := range jobs {
        results <- j * 2  // 处理任务，发送结果
    }
}

func main() {
    jobs := make(chan int, 5)
    results := make(chan int, 5)

    go worker(1, jobs, results)

    jobs <- 1
    jobs <- 2
    jobs <- 3
    close(jobs)

    fmt.Println(<-results) // 2
    fmt.Println(<-results) // 4
    fmt.Println(<-results) // 6
}

// 用 channel 实现"等待任务完成"的信号
func main() {
    done := make(chan bool)

    go func() {
        fmt.Println("执行耗时操作...")
        time.Sleep(2 * time.Second)
        done <- true // 发信号：我做完了
    }()

    <-done // 阻塞等待信号
    fmt.Println("任务完成，继续执行")
}

func main() {
    ch := make(chan string)

    go func() {
        time.Sleep(3 * time.Second)
        ch <- "结果"
    }()

    select {
    case result := <-ch:
        fmt.Println("收到:", result)
    case <-time.After(1 * time.Second):
        fmt.Println("超时！")
    }
}
// 输出：超时！（因为 goroutine 需要 3 秒，而超时设了 1 秒）

ch := make(chan int)
close(ch)
ch <- 1  // panic: send on closed channel

func main() {
    ch := make(chan int)
    ch <- 1        // 阻塞！没有 goroutine 在接收
    fmt.Println(<-ch)
}
// fatal error: all goroutines are asleep - deadlock!

var ch chan int  // nil channel
select {
case ch <- 1:   // 永远不会执行（nil channel 永远阻塞）
default:
    fmt.Println("走 default")
}
// nil channel 在 select 中很有用：可以用 nil 来"禁用"某个 case

ch := make(chan int)
go func() {
    for i := 0; i < 3; i++ {
        ch <- i
    }
    // 忘了 close(ch)！
}()

for v := range ch {  // 死锁！永远等不到 close
    fmt.Println(v)
}

select {
case msg := <-ch1:
    // 如果 ch1 成功读到数据，则进行该 case 处理语句
    fmt.Println("收到 ch1:", msg)
case msg := <-ch2:
    // 如果 ch2 成功读到数据，则进行该 case 处理语句
    fmt.Println("收到 ch2:", msg)
case <-time.After(1 * time.Second):
    fmt.Println("超时")
default:
    fmt.Println("无数据，不阻塞")
}

// WaitGroup - 等待多个 goroutine 完成
var wg sync.WaitGroup
for i := 0; i < 5; i++ {
    wg.Add(1)
    go func(id int) {
        defer wg.Done()
        fmt.Println("任务", id)
    }(i)
}
wg.Wait()

// Mutex - 互斥锁
var mu sync.Mutex
var counter int

func increment() {
    mu.Lock()
    defer mu.Unlock()
    counter++
}

// RWMutex - 读写锁
var rwmu sync.RWMutex
func read() {
    rwmu.RLock()
    defer rwmu.RUnlock()
    // 读操作
}
func write() {
    rwmu.Lock()
    defer rwmu.Unlock()
    // 写操作
}

// Once - 只执行一次
var once sync.Once
func initConfig() {
    once.Do(func() {
        // 初始化代码，只执行一次
    })
}

// 创建 context
ctx := context.Background()
ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
defer cancel()

// 在 goroutine 中使用
func doWork(ctx context.Context) {
    select {
    case <-ctx.Done():
        fmt.Println("任务取消")
        return
    case <-time.After(10 * time.Second):
        fmt.Println("任务完成")
    }
}

// 传递 value（慎用）
ctx = context.WithValue(ctx, "key", "value")

// Java - 线程池 + Future
ExecutorService executor = Executors.newFixedThreadPool(5);
List<Future<Integer>> futures = new ArrayList<>();

for (int i = 0; i < 5; i++) {
    futures.add(executor.submit(() -> {
        return compute(i);
    }));
}

for (Future<Integer> f : futures) {
    System.out.println(f.get());
}
executor.shutdown();
// Go - Goroutine + Channel
results := make(chan int, 5)
for i := 0; i < 5; i++ {
    go func(id int) {
        results <- compute(id)
    }(i)
}

for i := 0; i < 5; i++ {
    fmt.Println(<-results)
}

// add_test.go
func TestAdd(t *testing.T) {
    result := Add(2, 3)
    if result != 5 {
        t.Errorf("期望 5，实际 %d", result)
    }
}

// 表格驱动测试（推荐）
func TestAddTable(t *testing.T) {
    tests := []struct {
        a, b, expected int
    }{
        {1, 2, 3},
        {0, 0, 0},
        {-1, 1, 0},
    }
    
    for _, tt := range tests {
        t.Run(fmt.Sprintf("%d+%d", tt.a, tt.b), func(t *testing.T) {
            result := Add(tt.a, tt.b)
            if result != tt.expected {
                t.Errorf("期望 %d，实际 %d", tt.expected, result)
            }
        })
    }
}

func BenchmarkAdd(b *testing.B) {
    for i := 0; i < b.N; i++ {
        Add(2, 3)
    }
}

// 运行性能测试
// go test -bench=. -benchmem

# 生成覆盖率报告
go test -coverprofile=coverage.out
go tool cover -html=coverage.out  # 生成 HTML 报告

# 查看覆盖率
go test -cover

// 测试辅助函数（以 T 或 B 为第一个参数）
func setupTest(t *testing.T) {
    t.Helper()  // 标记为辅助函数，错误显示调用者位置
    // 初始化代码
}

// 并行测试
func TestParallel(t *testing.T) {
    t.Parallel()  // 标记为可并行执行
    // 测试代码
}

# 检测数据竞争
go test -race ./...

# 生成性能分析
go test -cpuprofile=cpu.prof -memprofile=mem.prof

# 使用 pprof 分析
go tool pprof cpu.prof

缩进：使用 Tab（gofmt 默认）
行长度：Go 没有行长度限制，如果一行太长，换行并多缩进一个 Tab
括号：控制结构（if/for/switch）不需要括号包裹条件表达式

// 推荐：Getter 直接用字段名（首字母大写）
func (u *User) Owner() string { return u.owner }

// 不推荐：写为 GetOwner()
func (u *User) GetOwner() string { return u.owner }

// Setter 可以加 Set 前缀
func (u *User) SetOwner(name string) { u.owner = name }

// 推荐
var maxLength int
func NewUser() *User {}

// 不推荐
var max_length int  

// NewUser 创建一个指定 name 的 User 实例。
// 如果 name 为空，返回错误。
func NewUser(name string) (*User, error) { ... }

project/
├── cmd/              # 可执行程序
│   └── main/
│       └── main.go
├── internal/         # 私有包（外部不可导入）
│   └── pkg/
├── pkg/              # 公共包
├── api/              # API 定义
├── configs/          # 配置文件
├── scripts/          # 脚本文件
├── tests/            # 集成测试
├── go.mod
└── go.sum