Go 复合类型

// 声明
var a [3]int                     // [0, 0, 0]，长度是类型的一部分
b := [3]int{1, 2, 3}             // [1, 2, 3]
c := [...]int{1, 2, 3, 4}        // 自动推断长度 [4]int
d := [5]int{0: 10, 4: 50}        // 索引初始化 [10, 0, 0, 0, 50]

a := [3]int{1, 2, 3}
b := a                           // 完整复制
b[0] = 99
fmt.Println(a[0])                // 1（未受影响）

fmt.Println([3]int{1, 2, 3} == [3]int{1, 2, 3})  // true

// runtime/slice.go（简化）
type slice struct {
    array unsafe.Pointer          // 指向底层数组的指针
    len   int                     // 当前元素个数
    cap   int                     // 从 array 起点到底层数组末尾的可用长度
}

// 方式一：字面量
s := []int{1, 2, 3}

// 方式二：make
s := make([]int, 3)               // len=3, cap=3
s := make([]int, 3, 5)            // len=3, cap=5（预分配容量）

// 方式三：从数组/切片截取
arr := [5]int{1, 2, 3, 4, 5}
s := arr[1:4]                     // [2, 3, 4]，len=3, cap=4（cap 从起点算到数组末尾：5-1）
s := arr[:3]                      // [1, 2, 3]，len=3, cap=5
s := arr[2:]                      // [3, 4, 5]，len=3, cap=3

// 方式四：nil 切片 vs 空切片
var s []int                       // nil 切片（len=0, cap=0，s == nil 为 true）
s := []int{}                      // 空切片（len=0, cap=0，s == nil 为 false）
s := make([]int, 0)               // 空切片

s := []int{1, 2, 3}
s = append(s, 4)                  // [1, 2, 3, 4]
s = append(s, 5, 6, 7)            // 追加多个元素
s = append(s, otherSlice...)      // 展开另一个切片

parent := []int{1, 2, 3, 4, 5}
child := parent[1:3]              // [2, 3]，len=2，cap=4

// 两者共享底层数组！
child[0] = 99
fmt.Println(parent)               // [1, 99, 3, 4, 5]（实测：parent 也被改了）

// append 只要没超出 child 的 cap，写入的也是共享的底层数组
child = append(child, 100)
fmt.Println(parent)               // [1, 99, 3, 100, 5]（实测：100 落在 parent[3]，覆盖了 4）

// 方式一：限制 cap（三索引截取，Go 1.2+）
child := parent[1:3:3]            // [2, 3]，len=2，cap=2（第三个索引 3 是底层数组内的上限位置）
                                  // cap = 3-1 = 2，append 必然分配新数组

// 方式二：显式复制
child := make([]int, 2)
copy(child, parent[1:3])

// 方式三：slices.Clone（Go 1.21+）
import "slices"
child := slices.Clone(parent[1:3])

src := []int{1, 2, 3, 4, 5}
dst := make([]int, 3)
n := copy(dst, src)               // n=3, dst=[1,2,3]（按 min(len(dst), len(src)) 截断）

// 遍历
for i, v := range s { }

// 删除索引 i 的元素（保持顺序）
s = append(s[:i], s[i+1:]...)

// 删除索引 i（不保持顺序，更快）
s[i] = s[len(s)-1]
s = s[:len(s)-1]

// 过滤
filtered := s[:0]
for _, v := range s {
    if keep(v) {
        filtered = append(filtered, v)
    }
}

// Go 1.21+：slices.Delete、slices.DeleteFunc（推荐，边界处理更省心）
import "slices"
s = slices.Delete(s, i, i+1)
s = slices.DeleteFunc(s, func(v int) bool { return v < 0 })

// 方式一：make
m := make(map[string]int)

// 方式二：字面量初始化
m := map[string]int{
    "a": 1,
    "b": 2,
}

// 基本操作
m["c"] = 3                       // 写入
v := m["a"]                      // 读取（key 不存在返回零值）
v, ok := m["z"]                  // 安全读取（ok 表示 key 是否存在）
delete(m, "a")                   // 删除（key 不存在不会 panic；对 nil map 执行 delete 也是安全的空操作，实测）

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

var m1 map[string]int             // nil map
m2 := map[string]int{}            // 空 map

// 读操作（都安全）
v := m1["key"]                    // 返回零值，不 panic

// 写操作
m1["key"] = 1                     // panic: assignment to entry in nil map（实测）
m2["key"] = 1                     // OK

m1 := map[string]int{"a": 1}
m2 := map[string]int{"a": 1}
// fmt.Println(m1 == m2)          // 编译错误！map 之间不能用 == 比较（只能与 nil 比较）

// 如需内容级比较，用 maps 包（Go 1.21+）
import "maps"
fmt.Println(maps.Equal(m1, m2))   // true（Go 1.21+）

// 错误：并发读写 map 会引发 fatal error
go func() { for { m["key"] = 1 } }()
go func() { for { _ = m["key"] } }()
// fatal error: concurrent map read and map write（读写并发）或 concurrent map writes（写写并发）

// 解决方案一：sync.RWMutex
var mu sync.RWMutex
mu.RLock(); v := m["key"]; mu.RUnlock()
mu.Lock(); m["key"] = v; mu.Unlock()

// 解决方案二：sync.Map（特定场景）
var sm sync.Map
sm.Store("key", 1)
v, ok := sm.Load("key")

m := make(map[string]int, 100)    // 预分配约 100 个元素的空间

type Person struct {
    Name  string
    Age   int
    Email string
}

// 初始化方式
p1 := Person{"Alice", 30, "alice@example.com"}     // 无 key 按顺序（不推荐，见下方注意）
p2 := Person{                                      // 按字段名（推荐）
    Name:  "Bob",
    Age:   25,
    Email: "bob@example.com",
}
p3 := Person{Name: "Charlie"}                       // 部分字段，其余为零值
p4 := new(Person)                                   // 返回 *Person，字段全零值

p.Name = "Dave"
fmt.Println(p.Age)

// 指针自动解引用
ptr := &Person{Name: "Eve", Age: 22}
fmt.Println(ptr.Name)             // 不需要 (*ptr).Name
ptr.Age = 23                      // 直接通过指针修改

type Point struct{ X, Y int }
p1 := Point{1, 2}
p2 := Point{1, 2}
fmt.Println(p1 == p2)             // true（所有字段可比较时可用 == ，逐字段比较）

// 含有 map、slice、function 字段的结构体不能比较
type Foo struct {
    Data []int
}
// f1 == f2 → 编译错误

empty := struct{}{}               // 零内存占用（0 字节）
set := make(map[string]struct{})  // 用做 set：value 不占内存
set["key"] = struct{}{}

// chan 用作纯信号
done := make(chan struct{})
done <- struct{}{}

type User struct {
    ID     int    `json:"id" db:"user_id" validate:"required"`
    Name   string `json:"name" db:"name"`
    Score  int    `json:"score,omitempty"`          // omitempty: 零值时省略
    secret string `json:"-"`                         // -: 忽略该字段
}

field, _ := reflect.TypeOf(User{}).FieldByName("Name")
tag := field.Tag.Get("json")      // "name"

type Animal struct {
    Name string
}

func (a Animal) Speak() string {
    return "..."
}

type Dog struct {
    Animal                          // 嵌入 Animal（无字段名，字段名就是类型名）
    Breed string
}

// 传统写法：手动嵌套
d1 := Dog{
    Animal: Animal{Name: "Buddy"},
    Breed:  "Golden Retriever",
}

// Go 1.27 起等价（提升字段名直接作 key，见下一小节）
d2 := Dog{Name: "Buddy", Breed: "Golden Retriever"}

fmt.Println(d2.Name)              // "Buddy"（提升的字段）
fmt.Println(d2.Speak())           // "..."（提升的方法）
fmt.Printf("d2: %+v\n", d2)       // 实测输出：d2: {Animal:{Name:Buddy} Breed:Golden Retriever}
fmt.Println(d1 == d2)             // true——两种写法产物完全一致

cfg := Config{Name: "app", DB: DB{Host: "localhost", Port: 5432}}

type DB struct {
    Host string
    Port int
}

type Config struct {
    Name string
    DB                              // 值类型嵌入
}

cfg := Config{Name: "app", Host: "localhost", Port: 5432}
fmt.Printf("cfg: %+v\n", cfg)
// 实测输出（go1.27.0）：
// cfg: {Name:app DB:{Host:localhost Port:5432}}

type Base struct{ ID int }
type Mid struct{ Base }
type Top struct {
    Mid
    Name string
}

top := Top{Name: "t", ID: 7}        // ID 从两层之下的 Base 提升上来
fmt.Printf("top: %+v\n", top)
// 实测输出：top: {Mid:{Base:{ID:7}} Name:t}

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

var nilPtr *int                   // nil 指针
// *nilPtr                         // panic: runtime error: invalid memory address or nil pointer dereference（实测）

p := new(int)                     // *int，指向 0
s := make([]int, 3)               // []int，[0, 0, 0]

// new 很少使用，通常用 &T{} 代替（还能顺便给字段赋初值）
p := &Person{Name: "Ann"}

func byValue(p Person) { p.Name = "changed" }     // 不影响调用方（操作的是副本）
func byPtr(p *Person)  { p.Name = "changed" }     // 影响调用方

import "slices"

s := []int{3, 1, 2}
slices.Sort(s)                    // 实测 [1 2 3]，原地排序
slices.SortFunc(s, func(a, b int) int { return b - a })        // 实测 [3 2 1]，cmp 返回负/零/正
slices.SortStableFunc(s, func(a, b int) int { return a - b })  // 稳定排序，实测回到 [1 2 3]
i, found := slices.BinarySearch(s, 2)   // 要求已排序；实测 i=1, found=true（返回插入位置与命中标志）

slices.Index(s, 2)                // 实测 1（找不到返回 -1）
slices.IndexFunc(s, func(v int) bool { return v == 3 })  // 实测 2
slices.Contains(s, 3)             // 实测 true（元素需 comparable）
slices.Max(s)                     // 实测 3
slices.Min(s)                     // 实测 1
slices.Equal(s, []int{1, 2, 3})   // 实测 true，逐元素 ==
cl := slices.Clone(s)             // 浅拷贝（安全分离底层数组）
slices.Reverse(cl)                // 实测 cl=[3 2 1]，s 保持 [1 2 3] 不受影响
s = slices.Delete(s, 0, 2)        // 实测 [3]：删除 [0:2]，后面的元素前移
fmt.Println(slices.DeleteFunc([]int{1, -2, 3, -4},
        func(v int) bool { return v < 0 }))  // 实测 [1 3]
fmt.Println(slices.Compact([]int{1, 1, 2}))  // 实测 [1 2]，连续重复只留一个

import "maps"

m1 := map[string]int{"a": 1, "b": 2}
m2 := map[string]int{"a": 1, "b": 2}
fmt.Println(maps.Equal(m1, m2))    // true
clone := maps.Clone(m1)            // 浅拷贝（对 nil map 调用返回 nil，实测）
maps.Copy(clone, m2)               // 把 src 全部键值对并入 dst；注意它没有返回值（实测 go doc 签名）
maps.DeleteFunc(m1, func(k string, v int) bool { return v < 0 })

// Keys/Values 返回 iter.Seq 迭代器，可直接 range（实测 go doc：Keys 返回 iter.Seq[K]，需模块 go ≥ 1.23）
for k := range maps.Keys(m1) { _ = k }

a := []int{1, 2, 3, 4, 5}
b := a[1:3]                        // len=2, cap=4，b 的写窗口一直到 a 的末尾
b[0] = 9                           // 改的是 a[1]！
b = append(b, 100)                 // 实测：a 变成 [1 9 3 100 5]——append 落在 a[3]
// 解决方案：三索引切片限制 cap（第三个索引是底层数组内的边界位置，cap = 边界 - 起点）
c := a[1:3:3]                      // len=2, cap=2，append 必分配新数组，a 不受影响

s := make([]int, 0, 2)
t := append(s, 1)                  // 结果赋给了 t，没有写回 s
fmt.Println(s, len(s))             // 实测：[] 0 —— s 完全看不到这个 1
fmt.Println(t, len(t))             // 实测：[1] 1

var m map[string]int
m["key"] = 1                       // panic: assignment to entry in nil map（实测）

type A struct{ Name string }
func (a *A) SetName(n string) { a.Name = n }

type B struct {
    *A                              // 嵌入指针
}

b := B{A: &A{}}                    // 必须初始化 A
b.SetName("test")                   // OK
fmt.Println(b.Name)                 // "test"
// 但空指针窗口就在初始化：var bad B; bad.SetName("test")
// → panic: runtime error: invalid memory address or nil pointer dereference（实测）

items := []Person{
    {Name: "Alice", Age: 30},
    {Name: "Bob", Age: 25},
}
for _, p := range items {
    p.Age = 0                       // 修改的是副本！items 不变
}
for i := range items {
    items[i].Age = 0                // 通过索引修改原数据
}