Go 学习笔记#

package main

import "fmt"

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

// 完整声明
var name string          // 零值 ""（不会是 null/undefined）
var age int = 25         // 声明并初始化
var score = 95.5         // 类型推断 → float64

// 短变量声明（只能在函数内部用）
name := "Alice"          // 等价于 var name string = "Alice"
count, err := 10, nil    // 多变量同时声明

// 批量声明
var (
    host   string = "localhost"
    port   int    = 8080
    debug  bool   = true
)

var i int = 42
var f float64 = float64(i)    // 必须显式转换

// 字符串与数值的转换需要 strconv 包
s := strconv.Itoa(42)              // int → string
n, err := strconv.Atoi("42")       // string → int

const Pi = 3.14159
const MaxConn int = 100

// iota：枚举器
const (
    Sunday = iota    // 0
    Monday           // 1（iota 自动递增）
    Tuesday          // 2
)

// iota 高级用法：位运算枚举
const (
    Read    = 1 << iota   // 1
    Write                 // 2
    Execute               // 4
)
// perms := Read | Write  → 3

// iota 跳值
const (
    _  = iota             // 跳过 0
    KB = 1 << (10 * iota) // 1024
    MB                    // 1 << 20
    GB                    // 1 << 30
)

s := "Hello, 世界"

fmt.Println(len(s))           // 13（字节长度，不是字符数！）
fmt.Println(s[0])             // 72（byte 值，不是字符）

// 遍历 rune（正确方式）
for i, r := range s {
    fmt.Printf("%d:%c ", i, r) // 0:H 1:e ... 7:世 10:界
}

// 字符串 ↔ []rune
runes := []rune(s)
fmt.Println(len(runes))       // 9（字符数）

// 条件不需要括号
if x > 0 {
    fmt.Println("正数")
} else if x == 0 {
    fmt.Println("零")
} else {
    fmt.Println("负数")
}

// 带初始化语句（Go 特色）
if err := doSomething(); err != nil {
    log.Fatal(err)
}
// err 的作用域仅限于 if-else 块内

// 经典三段式
for i := 0; i < 10; i++ { ... }

// while 形式
for count < 100 { count *= 2 }

// 无限循环
for { if done { break } }

// range 遍历
for index, value := range slice { ... }
for _, v := range slice { ... }   // 只要值

// 遍历 map（顺序随机！）
for key, value := range m { ... }

// 自动 break，不需要手动写！
switch day {
case "Sat", "Sun":
    fmt.Println("周末")
default:
    fmt.Println("工作日")
}

// 表达式 switch
switch {
case score >= 90:
    grade = "A"
case score >= 60:
    grade = "C"
default:
    grade = "F"
}

// fallthrough：强制进入下一个 case
switch x {
case 1:
    fmt.Println("一")
    fallthrough
case 2:
    fmt.Println("二")
}

func writeFile() error {
    f, err := os.Create("test.txt")
    if err != nil {
        return err
    }
    defer f.Close()        // 延迟到函数返回时执行
    f.WriteString("hello")
    return nil             // f.Close() 在这里执行
}

i := 1
defer fmt.Println(i)   // 输出 1，不是 2
i = 2

func f() (result int) {
    defer func() { result++ }()
    return 0   // 实际返回 1
}

// 基本形式
func add(a, b int) int {
    return a + b
}

// 多返回值（Go 的标志性特性）
func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, errors.New("division by zero")
    }
    return a / b, nil
}

// 命名返回值
func split(sum int) (x, y int) {
    x = sum * 4 / 9
    y = sum - x
    return              // naked return，自动返回 x, y
}

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

sum(1, 2, 3)          // 6
nums := []int{1, 2, 3}
sum(nums...)          // 传切片给可变参数

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

c := counter()
c()   // 1
c()   // 2

func apply(f func(int) int, x int) int { return f(x) }

result := apply(func(x int) int { return x * 2 }, 5)  // 10

type MathFunc func(float64) float64

// init 在 main 之前自动执行，每文件可有多个
func init() { fmt.Println("初始化") }
// 执行顺序：被导入包的 init → 本包 init → main

var arr [5]int                    // [0 0 0 0 0]
arr := [5]int{1, 2, 3, 4, 5}
arr := [...]int{1, 2, 3}         // 编译器推断长度

// 数组是值类型！赋值是拷贝
a := [3]int{1, 2, 3}
b := a
b[0] = 99
fmt.Println(a)   // [1 2 3] —— a 不受影响

var s []int                       // nil 切片
s := []int{1, 2, 3}
s := make([]int, 5)               // 长度5，容量5
s := make([]int, 5, 10)           // 长度5，容量10

s = append(s, 4)                  // 追加元素
s2 := s[1:3]                     // 切片操作
len(s)                            // 长度
cap(s)                            // 容量

// 陷阱1：切片共享底层数组
a := []int{1, 2, 3, 4, 5}
b := a[1:3]           // b 和 a 共享底层数组
b[0] = 99
fmt.Println(a)         // [1, 99, 3, 4, 5] —— a 也被改了！
// 解决：用 copy 创建独立副本

// 陷阱2：大切片的小引用阻止 GC
big := make([]byte, 1<<20)    // 1MB
small := big[:10]             // small 只用 10 字节，但底层数组还是 1MB

m := map[string]int{"alice": 25, "bob": 30}
m := make(map[string]int)        // 空 map
var m map[string]int              // nil map（不能直接写！）

m["charlie"] = 35                 // 添加/修改
age := m["alice"]                 // 读取（不存在返回零值）
age, ok := m["david"]            // 检查是否存在
delete(m, "bob")                  // 删除

for name, age := range m { ... }  // 遍历（顺序随机！）

// string ↔ []byte
s := string([]byte{72, 101, 108, 108, 111})   // "Hello"
b := []byte("hello")

// strings 包常用函数
strings.Contains("hello", "ell")     // true
strings.HasPrefix("hello", "he")     // true
strings.Split("a,b,c", ",")          // ["a", "b", "c"]
strings.Join([]string{"a","b"}, "-") // "a-b"
strings.Fields("  hello  world  ")    // ["hello", "world"]

x := 42
p := &x              // p 是指向 x 的指针，类型 *int
fmt.Println(*p)      // 42（解引用）
*p = 100             // 通过指针修改 x

p := new(int)        // 分配零值并返回指针
*p = 42

// 值传递：函数内修改不影响外部
func modifyValue(s struct{ X int }) { s.X = 100 }

// 指针传递：函数内修改影响外部
func modifyPointer(s *struct{ X int }) { s.X = 100 }

type Person struct {
    Name string
    Age  int
}

p1 := Person{"Alice", 25}           // 按顺序
p2 := Person{Name: "Bob", Age: 30}  // 按字段名（推荐）
p4 := &Person{Name: "Charlie"}      // 取地址

// 匿名字段（嵌入）
type Employee struct {
    Person           // 匿名嵌入（不是继承！）
    Company string
}
emp := Employee{Person: Person{Name: "Dave"}, Company: "Google"}
fmt.Println(emp.Name)     // 直接访问嵌入字段（提升）

type Rectangle struct {
    Width, Height float64
}

// 值接收者方法
func (r Rectangle) Area() float64 { return r.Width * r.Height }

// 指针接收者方法
func (r *Rectangle) Scale(factor float64) {
    r.Width *= factor
    r.Height *= factor
}

type User struct {
    Name string `json:"name" validate:"required"`
    Age  int    `json:"age" validate:"gte=0,lte=120"`
    Email string `json:"email,omitempty"`
}

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

// 组合接口
type ReadWriter interface {
    Reader
    Writer
}

// 隐式实现——不需要声明 "implements"
type File struct {}
func (f *File) Read(p []byte) (n int, err error) { /* ... */ }
func (f *File) Write(p []byte) (n int, err error) { /* ... */ }

// File 自动实现了 ReadWriter 接口！
var rw ReadWriter = &File{}

// 空接口：任何类型都实现了空接口
var any interface{} = 42
var any2 any = "hello"   // Go 1.18+ 用 any 代替 interface{}

// 类型断言
var i interface{} = "hello"
s, ok := i.(string)    // s="hello", ok=true

// type switch
switch v := i.(type) {
case string:
    fmt.Println("string:", v)
case int:
    fmt.Println("int:", v)
default:
    fmt.Println("unknown")
}

var p *int = nil
var i interface{} = p
fmt.Println(i == nil)   // false！

// Stringer：类似 Java toString()
type Stringer interface { String() string }

// error：Go 的错误就是一个接口
type error interface { Error() string }

// error 就是一个接口
type error interface { Error() string }

err := errors.New("something went wrong")
err := fmt.Errorf("user %s not found", name)

result, err := doSomething()
if err != nil {
    return err
}

// 自定义结构体
type ValidationError struct {
    Field   string
    Message string
}
func (e *ValidationError) Error() string {
    return fmt.Sprintf("validation failed on %s: %s", e.Field, e.Message)
}

// 哨兵错误
var (
    ErrNotFound = errors.New("not found")
    ErrInvalid  = errors.New("invalid input")
)

if errors.Is(err, ErrNotFound) { ... }

// 包装错误（添加上下文）
return fmt.Errorf("init: %w", err)   // %w 包装，%v 不包装

// 拆包判断
if errors.Is(err, os.ErrNotExist) { ... }  // 值匹配

var pathErr *fs.PathError
if errors.As(err, &pathErr) { ... }  // 类型匹配

// panic：不可恢复的严重错误
func mustParse(s string) int {
    n, err := strconv.Atoi(s)
    if err != nil { panic(err) }
    return n
}

// recover：在 defer 中捕获 panic
func safeCall() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("recovered:", r)
        }
    }()
    panic("boom")
}

// 导出规则：首字母大写 = 导出，小写 = 包内私有
func Add(x, y int) int { return x + y }   // 导出
func helper(x int) int { return x * 2 }    // 私有

module example.com/myproject

go 1.23

require (
    github.com/gin-gonic/gin v1.9.1
)

replace (
    example.com/mylib => ../mylib  // 本地替换
)

exclude (
    github.com/some/pkg v1.2.3  // 排除有 bug 的版本
)

import (
    "fmt"
    "os"
    f "fmt"                    // 别名
    _ "github.com/lib/pq"      // 空别名：只执行 init()
    . "github.com/stretchr/testify/assert"  // 点导入（不推荐）
)

// 启动 goroutine：go 关键字
go doWork()
go func() { fmt.Println("running") }()

// 等待多个 goroutine
var wg sync.WaitGroup
for i := 0; i < 5; i++ {
    wg.Add(1)
    go func(i int) {
        defer wg.Done()
        fmt.Printf("worker %d\n", i)
    }(i)
}
wg.Wait()

// 无缓冲通道（同步）
ch := make(chan int)
ch <- 42                    // 发送（阻塞直到有人接收）
n := <-ch                   // 接收（阻塞直到有人发送）

// 有缓冲通道（异步）
ch := make(chan int, 3)     // 缓冲区大小 3
ch <- 1                     // 不阻塞（缓冲区未满）

close(ch)                   // 关闭通道
for v := range ch { ... }   // 遍历直到关闭
v, ok := <-ch               // ok=false 表示已关闭且无数据

select {
case v := <-ch1:
    fmt.Println("从 ch1 收到", v)
case ch2 <- 42:
    fmt.Println("向 ch2 发送")
case <-time.After(3 * time.Second):
    fmt.Println("超时")
default:
    fmt.Println("没有就绪的 channel")
}

func worker(id int, jobs <-chan int, results chan<- int) {
    for j := range jobs {
        results <- j * j
    }
}

func main() {
    jobs := make(chan int, 100)
    results := make(chan int, 100)
    for w := 1; w <= 3; w++ {
        go worker(w, jobs, results)
    }
    for j := 1; j <= 10; j++ { jobs <- j }
    close(jobs)
    for r := 1; r <= 10; r++ { fmt.Println(<-results) }
}

func generate(nums ...int) <-chan int {
    out := make(chan int)
    go func() {
        defer close(out)
        for _, n := range nums { out <- n }
    }()
    return out
}

func square(in <-chan int) <-chan int {
    out := make(chan int)
    go func() {
        defer close(out)
        for n := range in { out <- n * n }
    }()
    return out
}

// 组合管道
for r := range square(generate(1, 2, 3, 4, 5)) {
    fmt.Println(r)   // 1 4 9 16 25
}

// 创建可取消的 context
ctx, cancel := context.WithCancel(context.Background())
defer cancel()

// 带超时
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()

// 在 goroutine 中检查取消信号
go func(ctx context.Context) {
    for {
        select {
        case <-ctx.Done():
            return   // 收到取消信号，退出
        default:
            // 继续工作
        }
    }
}(ctx)

// 传递 context 到下游 HTTP 请求
req, _ := http.NewRequestWithContext(ctx, "GET", url, nil)

// Mutex：互斥锁
var mu sync.Mutex
mu.Lock()
// 临界区
mu.Unlock()

// RWMutex：读写锁（读多写少场景）
var rwmu sync.RWMutex
rwmu.RLock()    // 读锁（允许多个读）
rwmu.RUnlock()
rwmu.Lock()     // 写锁（独占）
rwmu.Unlock()

// Once：只执行一次（单例模式）
var once sync.Once
once.Do(func() {
    // 初始化代码，保证只执行一次
})

// Cond：条件变量
cond := sync.NewCond(&mu)
cond.Wait()     // 等待通知
cond.Signal()   // 唤醒一个等待者
cond.Broadcast() // 唤醒所有等待者

// atomic：原子操作
var count int64
atomic.AddInt64(&count, 1)       // 原子加
atomic.LoadInt64(&count)         // 原子读
atomic.StoreInt64(&count, 0)     // 原子写

// 类型参数 [T any]
func Print[T any](s []T) {
    for _, v := range s {
        fmt.Println(v)
    }
}

Print[int]([]int{1, 2, 3})    // 显式类型
Print([]string{"a", "b"})     // 类型推断

// 多类型参数
func Map[T, U any](s []T, f func(T) U) []U {
    result := make([]U, len(s))
    for i, v := range s {
        result[i] = f(v)
    }
    return result
}

nums := []int{1, 2, 3}
squares := Map(nums, func(n int) int { return n * n })

// 内置约束
// any     = 任意类型（interface{} 的别名）
// comparable = 支持 == 和 != 的类型

// 自定义约束
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 MyInt int
type Number2 interface {
    ~int | ~int64 | ~float64
}

// 使用 golang.org/x/exp/constraints 包（或标准库 cmp 包，Go 1.21+）
// constraints.Ordered 约束：支持 < > <= >=