Go 语言开发指南

// 完整声明
var x int = 10
var name string = "Alice"

// 类型推断（省略类型）
var x = 10
var name = "Alice"

// 常量（无 final 关键字）
const PI = 3.14

// 短变量声明（只能在函数内）
y := 20
city := "Beijing"

// 多变量
a, b, c := 1, 2, 3

var i int = 100
var l int64 = int64(i)   // 必须显式
var d float64 = float64(i) // 必须显式

var n int = int(3.14)       // 显式

if x > 0 {            // 无括号！
    ...
} else if x == 0 {
    ...
} else {
    ...
}

// 初始化语句（Go 特色）
if v, err := compute(); err != nil {
    return err
} else {
    use(v)
}

switch day {
case "Sat", "Sun":         // 多值一行
    weekend()
default:
    weekday()
}

// 无表达式 switch = if-else 链
switch {
case x < 0:
    negative()
case x == 0:
    zero()
default:
    positive()
}

// 强制穿透
switch x {
case 1:
    a()
    fallthrough      // 显式穿透
case 2:
    b()
}

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

// while 风格
for cond { ... }

// 无限循环
for { ... }

// range（增强 for）
for i, v := range slice {
    // i 索引, v 值
}
for _, v := range slice {  // 忽略索引
    ...
}
for k, v := range m {     // map 遍历
    ...
}

f, err := os.Open("file.txt")
if err != nil {
    return err
}
defer f.Close()   // 紧跟 Open，确保释放

// 多个 defer，LIFO 执行
defer fmt.Println("1")
defer fmt.Println("2")
// 输出：2 然后 1

// func 函数名(参数) 返回类型
func Add(a, b int) int {   // 同类型参数可合并
    return a + b
}

// 大写 Add = 公开（包外可调用）
// 小写 greet = 包内私有
func greet(name string) string {
    return "Hi, " + name
}

// ❌ Go 不支持方法重载！
// 下面的会编译报错：Add redeclared
func Add(a, b, c int) int {
    return a + b + c
}

type User struct { Age int }

func grow(u User) {
    u.Age++           // ❌ 改的是副本！
}

u := User{Age: 18}
grow(u)
fmt.Println(u.Age)       // 仍然是 18

// ✅ 正确：传指针
func grow(u *User) {
    u.Age++           // 通过指针改原对象
}
grow(&u)
fmt.Println(u.Age)       // 19

func readFile(path string) (string, error) {
    ...
    return content, nil
}

// 调用：必须处理 error
content, err := readFile("a.txt")
if err != nil {
    return err
}
use(content)

// 忽略 error（不推荐）
content, _ := readFile("a.txt")

// 函数类型直接写
type IntFunc func(int) int

square := func(x int) int { return x * x }
r := square(5)

// 高阶函数
func compose(f, g IntFunc) IntFunc {
    return func(x int) int {
        return f(g(x))
    }
}

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

sum(1, 2, 3)             // 直接传

arr := []int{1, 2, 3}
sum(arr...)              // slice 要展开！

// config.go
package config

var cfg map[string]string

// 可有多个 init，按声明顺序执行
func init() {
    cfg = make(map[string]string)
    cfg["k"] = "v"
}

func init() {
    // 第二个 init，做其他初始化
    log.Println("config ready")
}

// 定长数组（很少用）
var arr [5]int
arr2 := [3]int{1, 2, 3}
arr3 := [...]int{1, 2, 3}  // ...自动推断长度

// 切片（最常用）
s := []int{1, 2, 3}
s = append(s, 4)       // 追加
s = append(s, 5, 6)
x := s[0]              // 取值
n := len(s)             // 长度

// make 创建
s2 := make([]int, 0, 10)  // len=0, cap=10

// 字面量
m := map[string]int{
    "a": 1,
    "b": 2,
}

// make 创建
m = make(map[string]int)

m["a"] = 1
m["b"] = 2

// 双返回值判断存在性
v, ok := m["a"]
if ok { ... }

// 不存在返回零值（不会 panic）
v = m["c"]   // v = 0

// 遍历（顺序不定）
for k, v := range m { ... }

// 删除
delete(m, "a")

set := map[string]struct{}{}
set["a"] = struct{}{}
set["b"] = struct{}{}
set["a"] = struct{}{}  // 重复，自动覆盖

_, has := set["a"]      // has = true
size := len(set)             // 2
delete(set, "a")

// 遍历（无序）
for k := range set {
    fmt.Println(k)
}

// Go 1.18+ 泛型封装 Set
type Set[T comparable] map[T]struct{}

func (s Set[T]) Has(v T) bool {
    _, ok := s[v]
    return ok
}

// 栈：用 slice（LIFO）
stack := []int{}
stack = append(stack, 1)      // push
stack = append(stack, 2)
top := stack[len(stack)-1]    // peek
stack = stack[:len(stack)-1]    // pop → 2

// 队列：用 slice（FIFO，效率低）
queue := []int{}
queue = append(queue, 1)
queue = append(queue, 2)
head := queue[0]            // peek
queue = queue[1:]            // dequeue → 1

// 队列：用 channel（并发安全，推荐）
ch := make(chan int, 100)
ch <- 1
head := <-ch                // dequeue

// 优先队列：container/heap
import "container/heap"
// 需实现 heap.Interface（较繁琐）

users := []User{
    {Name: "Bob", Age: 30},
    {Name: "Alice", Age: 25},
}

// 基本类型
nums := []int{3, 1, 2}
sort.Ints(nums)            // 升序
sort.Sort(sort.Reverse(sort.IntSlice(nums)))

// 自定义排序（Go 1.21+ 推荐）
slices.SortFunc(users, func(a, b User) int {
    if a.Age != b.Age {
        return a.Age - b.Age    // 年龄升序
    }
    return strings.Compare(a.Name, b.Name)
})

// 旧写法（仍然支持）
sort.Slice(users, func(i, j int) bool {
    return users[i].Age < users[j].Age
})

s := []string{"a", "b", "c"}

// 包含
has := slices.Contains(s, "b")        // true

// 索引
idx := slices.Index(s, "c")           // 2

// 条件查找索引
i := slices.IndexFunc(s, func(v string) bool {
    return strings.HasPrefix(v, "b")
})

// 二分查找（需已排序）
pos, found := slices.BinarySearch(s, "b")
// pos=1, found=true

s := []string{"a", "b", "c", "d"}

// 插入（返回新 slice，原 slice 不变）
s = slices.Insert(s, 1, "x")
// [a, x, b, c, d]

// 删除索引 [2, 3)
s = slices.Delete(s, 2, 3)
// [a, x, c, d]

// 条件删除（类似 removeIf）
s = slices.DeleteFunc(s, func(v string) bool {
    return strings.HasPrefix(v, "a")
})

// 拷贝
cp := slices.Clone(s)

// 拼接多个 slice
all := slices.Concat(s1, s2, s3)

// 压缩连续重复元素
dup := []int{1, 1, 2, 3, 3, 3}
dup = slices.Compact(dup)  // [1, 2, 3]

m := map[string]int{"a": 1, "b": 2}

// 取所有 key（返回 slice，无序）
keys := maps.Keys(m)   // []string{"a", "b"}（顺序不定）

// 取所有 value
vals := maps.Values(m) // []int{1, 2}（顺序不定）

// 拷贝
cp := maps.Clone(m)

// 合并（将 src 合并到 dst）
maps.Copy(cp, other)

// 判断相等（逐 key-value）
eq := maps.Equal(m1, m2)

// 条件删除（原地，无需遍历）
maps.DeleteFunc(m, func(k string, v int) bool {
    return v == 0
})

// filter + map + sort
var names []string
for _, u := range users {
    if u.Age > 18 {
        names = append(names, u.Name)
    }
}
sort.Strings(names)

// 分组（groupingBy）
byCity := map[string][]User{}
for _, u := range users {
    byCity[u.City] = append(byCity[u.City], u)
}

// 统计（average）
var total int
for _, u := range users {
    total += u.Age
}
avgAge := float64(total) / float64(len(users))

// 去重（distinct）
seen := map[string]struct{}{}
var unique []string
for _, u := range users {
    if _, ok := seen[u.Name]; !ok {
        seen[u.Name] = struct{}{}
        unique = append(unique, u.Name)
    }
}

// Go 没有内置不可变集合
// 方式1：返回副本（防御性拷贝）
func (u *User) GetTags() []string {
    cp := make([]string, len(u.tags))
    copy(cp, u.tags)
    return cp
}

// 方式2：返回只读接口（无法 append）
type ReadOnlyList[T any] interface {
    Get(i int) T
    Len() int
}

// 方式3：第三方库（如 go-immutable）

// 方式1：sync.Map（高并发读多写少）
var m sync.Map
m.Store("a", 1)
v, ok := m.Load("a")
m.LoadOrStore("b", 2)  // 类似 computeIfAbsent

// 方式2：RWMutex + map（更灵活）
type SafeMap[K comparable, V any] struct {
    mu sync.RWMutex
    m  map[K]V
}
func (s *SafeMap[K, V]) Get(k K) (V, bool) {
    s.mu.RLock(); defer s.mu.RUnlock()
    v, ok := s.m[k]; return v, ok
}

type User struct {
    Name string   // 大写=公开
    Age  int      // 大写=公开
    email string  // 小写=包内私有
}

// 字面量初始化（多种）
u1 := User{Name: "Alice", Age: 30}
u2 := User{"Alice", 30, ""}  // 按顺序
u3 := User{Name: "Bob"}      // Age=0, email=""

// 取指针（new 或 &）
u4 := &User{Name: "Carol"}
u5 := new(User)              // *User，零值

// 访问字段（Go 自动解引用）
u1.Name = "Alice2"
u4.Age = 25   // u4 是指针，但直接用 . 访问

type User struct {
    Name string `json:"name" db:"user_name" validate:"required"`
    Age  int    `json:"age,omitempty"`
    Pass string `json:"-"`          // 序列化时忽略
}

type RegisterReq struct {
    Username string `validate:"required,min=2,max=20"`
    Email    string `validate:"required,email"`
    Age      int    `validate:"min=18,max=120"`
    Phone    string `validate:"required,e164"`
    // 或用 regex：
    // `validate:"required,regexp=^1\\d{10}$"`
}

import "github.com/go-playground/validator/v10"
v := validator.New()
err := v.Struct(req)   // 返回校验错误

type Counter struct {
    count int
}

// 指针接收者：能修改原对象
func (c *Counter) Inc() {
    c.count++
}

// 值接收者：操作副本，不改原对象
func (c Counter) Get() int {
    return c.count
}

c := &Counter{}      // 或 Counter{}，Go 自动取址
c.Inc()
n := c.Get()

type Speaker interface {
    Speak()
}

type Dog struct{}

// 只要 Dog 有 Speak() 方法，就自动实现 Speaker
// 无需 "implements" 关键字！
func (d Dog) Speak() {
    fmt.Println("Woof")
}

var s Speaker = Dog{}
s.Speak()

type Animal struct{}

func (a Animal) Breathe() {
    fmt.Println("呼吸")
}

type Dog struct {
    Animal      // 嵌入（无字段名）
}

func (d Dog) Bark() {
    fmt.Println("汪汪")
}

d := Dog{}
d.Breathe()   // 直接调用，像继承
d.Bark()

// 也可显式访问
d.Animal.Breathe()

func read(path string) (string, error) {
    b, err := os.ReadFile(path)
    if err != nil {
        return "", err
    }
    return string(b), nil
}

s, err := read("a.txt")
if err != nil {
    log.Printf("失败: %v", err)
    return
}
use(s)

u := &User{Name: "Alice"}
u2 := u          // 两个指针指向同一对象
u2.Name = "Bob"
fmt.Println(u.Name)   // Bob

// 所有类型赋值都是值拷贝
a := 10
b := a
b = 20
// a 仍然是 10

// 想让函数修改外部变量，传指针
func inc(n *int) { *n++ }
x := 10
inc(&x)
// x == 11

// 加一个 go 关键字即可！
go doWork()

// 匿名函数
go func() {
    doWork()
}()

// 带参数（注意传值，不要闭包捕获循环变量）
for i := 0; i < 100; i++ {
    go process(i)
}

// 无缓冲 channel（同步）
ch := make(chan int)

// 有缓冲 channel（异步）
ch := make(chan int, 10)

go func() {
    ch <- 42      // 发送
}()

v := <-ch         // 接收（阻塞直到有数据）

// 关闭 channel
close(ch)

// 遍历直到关闭
for v := range ch {
    use(v)
}

var wg sync.WaitGroup

for i := 0; i < 3; i++ {
    wg.Add(1)
    go func(id int) {
        defer wg.Done()   // 推荐用 defer
        doWork(id)
    }(i)
}
wg.Wait()  // 等待全部完成

module github.com/example/myapp

go 1.22

require (
    github.com/google/uuid v1.6.0
    golang.org/x/sync v0.6.0
)

# 常用命令
# go mod init github.com/example/myapp
# go get github.com/google/uuid@latest
# go mod tidy      # 清理未用依赖
# go mod vendor    # 供应商模式

t := reflect.TypeOf(obj)
v := reflect.ValueOf(obj)

// 读字段
f := v.FieldByName("Name")
name := f.String()

// 调用方法
m := v.MethodByName("Speak")
m.Call(nil)

// 修改字段（需传指针）
v = reflect.ValueOf(&obj).Elem()
v.FieldByName("Name").SetString("Bob")

type Box[T any] struct {
    value T
}

func (b *Box[T]) Get() T { return b.value }
func (b *Box[T]) Set(v T) { b.value = v }

b := &Box[string]{}
b.Set("hi")

// 类型约束
func Sum[T constraints.Ordered](xs []T) T {
    var s T
    for _, x := range xs { s += x }
    return s
}

// calculator_test.go（文件名必须 _test.go）
package calc

import "testing"

func TestAdd(t *testing.T) {
    calc := &Calculator{}
    got := calc.Add(2, 3)
    if got != 5 {
        t.Errorf("Add(2,3)=%d, want 5", got)
    }
}

// 表驱动测试（Go 特色）
func TestAdd_Table(t *testing.T) {
    cases := []struct {
        a, b, want int
    }{
        {1, 2, 3},
        {0, 0, 0},
        {-1, 1, 0},
    }
    for _, c := range cases {
        got := calc.Add(c.a, c.b)
        if got != c.want {
            t.Errorf("Add(%d,%d)=%d, want %d",
                c.a, c.b, got, c.want)
        }
    }
}

var sb strings.Builder
for _, s := range list {
    sb.WriteString(s)
}
r := sb.String()

// 已知数量的拼接用 Join 更快
r = strings.Join(list, ",")