Go 结构体和方法

结构体是 Go 语言中组织数据的核心方式，它将相关的数据组合在一起，形成有意义的整体。方法则是与特定类型关联的函数，让类型具有行为能力。理解结构体和方法是掌握 Go 面向对象编程的关键。

结构体基础

什么是结构体

结构体（struct）是一种聚合类型，它将零个或多个任意类型的值组合在一起。每个值称为结构体的字段（field），每个字段都有一个名称和一个类型。

想象一个"人"的概念：一个人有姓名、年龄、地址等属性。结构体就是把这些相关的属性打包成一个整体：

type Person struct {
    Name    string  // 姓名
    Age     int     // 年龄
    Address string  // 地址
}

这样，Person 就成为了一个新的类型，可以像使用 int、string 一样使用它。

结构体定义语法

type 结构体名 struct {
    字段名1 字段类型1
    字段名2 字段类型2
    // ...
}

命名规则：

结构体名使用大驼峰命名法（PascalCase），首字母大写表示可导出
字段名使用大驼峰或小驼峰，首字母大写表示可导出
字段名在同一结构体中必须唯一

type Student struct {
    Name   string   // 导出字段，其他包可以访问
    Age    int      // 导出字段
    score  float64  // 未导出字段，仅本包可访问
}

创建结构体实例

Go 提供了多种创建结构体实例的方式：

// 方式一：使用字段名初始化（推荐）
p1 := Person{
    Name:    "张三",
    Age:     25,
    Address: "北京市朝阳区",
}

// 方式二：按字段顺序初始化（必须全部字段）
p2 := Person{"李四", 30, "上海市浦东新区"}

// 方式三：部分初始化，未指定的字段为零值
p3 := Person{Name: "王五"}  // Age=0, Address=""

// 方式四：使用 new 函数，返回指针
p4 := new(Person)  // 所有字段为零值，返回 *Person
p4.Name = "赵六"

// 方式五：取地址初始化，返回指针
p5 := &Person{Name: "钱七"}

零值：结构体如果没有显式初始化，每个字段会被赋予对应类型的零值。

var p Person
// p.Name = ""（空字符串）
// p.Age = 0
// p.Address = ""

访问和修改字段

使用点号 . 操作符访问结构体字段：

p := Person{Name: "张三", Age: 25}

// 读取
fmt.Println(p.Name)  // 张三

// 修改
p.Age = 26

对于指针类型的结构体，Go 会自动解引用：

p := &Person{Name: "张三"}
fmt.Println(p.Name)   // 自动解引用，等价于 (*p).Name
p.Age = 25            // 自动解引用，等价于 (*p).Age = 25

零值可用设计原则

Go 语言有一个重要的设计理念：类型的零值应该是有意义的，可以直接使用。这意味着一个结构体即使没有显式初始化，也应该处于可用状态。

零值的意义

在 Effective Go 中明确指出：设计数据结构时应该让零值可以直接使用。这个原则使得代码更简洁，减少了显式构造的需求。

// 标准库中的例子：bytes.Buffer
var buf bytes.Buffer
buf.WriteString("hello")  // 直接使用，无需初始化

// 标准库中的例子：sync.Mutex
var mu sync.Mutex
mu.Lock()   // 直接使用，无需初始化
mu.Unlock()

bytes.Buffer 的文档明确说明："Buffer 的零值是一个空的 buffer，可以直接使用"。sync.Mutex 的零值是一个未锁定的互斥锁，同样可以直接使用。

设计零值可用的结构体

在设计结构体时，应该考虑如何让零值有意义：

// 好的设计：零值可用
type Counter struct {
    value int  // 零值为 0，合理
}

func (c *Counter) Inc() { c.value++ }
func (c *Counter) Value() int { return c.value }

var c Counter
fmt.Println(c.Value())  // 0，可以正常工作

// 好的设计：使用切片而非指针
type Stack struct {
    items []int  // 零值为 nil，append 可以处理 nil 切片
}

func (s *Stack) Push(item int) {
    s.items = append(s.items, item)
}

func (s *Stack) Pop() (int, bool) {
    if len(s.items) == 0 {
        return 0, false
    }
    item := s.items[len(s.items)-1]
    s.items = s.items[:len(s.items)-1]
    return item, true
}

var stack Stack
stack.Push(1)  // 可以正常工作

避免零值陷阱

有些情况下零值可能导致问题，需要特别处理：

// 不好的设计：零值可能导致问题
type Config struct {
    Timeout time.Duration  // 零值为 0，可能被误解为"无超时"
    Retries int            // 零值为 0，可能被误解为"不重试"
}

// 改进方案一：使用指针表示可选
type Config struct {
    Timeout *time.Duration  // nil 表示使用默认值
    Retries *int            // nil 表示使用默认值
}

// 改进方案二：使用构造函数强制初始化
func NewConfig() *Config {
    return &Config{
        Timeout: 30 * time.Second,
        Retries: 3,
    }
}

// 改进方案三：使用合理的默认值
type Config struct {
    Timeout time.Duration  // 文档说明 0 表示无超时限制
    Retries int            // 文档说明 0 表示不重试（即只尝试一次）
}

零值传递性

零值可用的属性是可以传递的：如果一个结构体的所有字段都是零值可用的，那么这个结构体本身也是零值可用的。

type Server struct {
    mu      sync.Mutex    // 零值可用
    buffer  bytes.Buffer  // 零值可用
    running bool          // 零值为 false，合理
}

var s Server
s.mu.Lock()
s.buffer.WriteString("hello")
s.mu.Unlock()
// 一切正常，无需初始化

零值与构造函数

虽然零值可用是一个好原则，但并非所有结构体都能满足。当需要强制初始化时，应该使用构造函数，并通过命名约定让用户知道：

// 私有结构体，强制使用构造函数
type server struct {
    addr string
    // 其他字段...
}

// 构造函数：命名以 New 开头
func NewServer(addr string) *server {
    return &server{addr: addr}
}

结构体内存布局

内存连续存储

结构体在内存中是连续存储的，每个字段按照定义顺序依次排列：

type Point struct {
    X int64
    Y int64
    Z int64
}

p := Point{X: 1, Y: 2, Z: 3}

内存布局示意：

地址:   1000      1008      1016
        ┌─────────┬─────────┬─────────┐
        │    X    │    Y    │    Z    │
        │   (1)   │   (2)   │   (3)   │
        └─────────┴─────────┴─────────┘
           8字节      8字节      8字节

可以使用 unsafe.Sizeof 查看结构体大小：

import "unsafe"

fmt.Println(unsafe.Sizeof(Point{}))  // 24 (3 * 8字节)

内存对齐与填充

现代 CPU 在访问内存时，通常按照字长（如 8 字节）为单位进行访问。如果数据没有对齐到字长的边界，CPU 需要多次访问才能读取完整数据，这会降低性能。因此，编译器会在结构体的字段之间添加"填充"（padding）字节，确保每个字段都对齐到合适的边界。

对齐规则：

每个字段的地址必须是其类型大小的整数倍
结构体整体大小必须是其最大字段大小的整数倍

// 示例：不当的字段顺序会导致内存浪费
type Bad struct {
    A bool    // 1 字节
    B int64   // 8 字节
    C bool    // 1 字节
}

type Good struct {
    A bool    // 1 字节
    C bool    // 1 字节
    // 6 字节填充
    B int64   // 8 字节
}

Bad 的内存布局（共 24 字节）：
┌───────┬─────────────────┬───────┬─────────────────┐
│ A (1) │  7 字节填充      │ B (8) │ C (1) │ 7 字节填充 │
└───────┴─────────────────┴───────┴─────────────────┘

Good 的内存布局（共 16 字节）：
┌───────┬───────┬─────────────────┐
│ A (1) │ C (1) │  6 字节填充      │ B (8) │
└───────┴───────┴─────────────────┘

使用 unsafe.Sizeof 和 unsafe.Alignof 验证：

import "unsafe"

fmt.Printf("Bad: %d 字节\n", unsafe.Sizeof(Bad{}))    // 24
fmt.Printf("Good: %d 字节\n", unsafe.Sizeof(Good{}))  // 16

优化建议：将相同类型的字段放在一起，或者按照字段大小从大到小排列，可以减少填充字节。

使用 unsafe.Offsetof 查看字段偏移

type Example struct {
    A bool
    B int64
    C int32
}

e := Example{}
fmt.Printf("A 偏移: %d\n", unsafe.Offsetof(e.A))  // 0
fmt.Printf("B 偏移: %d\n", unsafe.Offsetof(e.B))  // 8（对齐到 8 字节边界）
fmt.Printf("C 偏移: %d\n", unsafe.Offsetof(e.C))  // 16

方法

方法的本质

方法是带有接收者（receiver）的函数。它让类型具有"行为"，是实现面向对象编程的核心机制。与普通函数不同，方法必须属于某个类型，调用时通过该类型的实例来调用。

// 普通函数
func Area(width, height float64) float64 {
    return width * height
}

// 方法：属于 Rectangle 类型
func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}

方法声明的语法：

func (接收者 接收者类型) 方法名(参数) 返回值 {
    // 方法体
}

接收者就像是方法的"第一个参数"，但在调用时它放在点号前面：

rect.Area()  // rect 就是接收者

值接收者与指针接收者

Go 支持两种类型的接收者：值接收者和指针接收者。

值接收者：方法内部操作的是结构体的副本，不会修改原始结构体。

type Rectangle struct {
    Width  float64
    Height float64
}

// 值接收者：方法内操作副本
func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}

// 值接收者：无法修改原结构体
func (r Rectangle) DoubleWidth() {
    r.Width *= 2  // 只修改了副本，原结构体不变
}

指针接收者：方法内部操作的是结构体的指针，可以修改原始结构体。

// 指针接收者：可以修改原结构体
func (r *Rectangle) Scale(factor float64) {
    r.Width *= factor
    r.Height *= factor
}

使用示例：

rect := Rectangle{Width: 10, Height: 5}

// 调用值接收者方法
fmt.Println(rect.Area())  // 50

// 调用指针接收者方法
rect.Scale(2)
fmt.Println(rect.Area())  // 200（原结构体被修改）

// 调用无法修改的值接收者方法
rect.DoubleWidth()
fmt.Println(rect.Width)   // 20（没有变化！因为 DoubleWidth 操作的是副本）

如何选择接收者类型

场景	推荐使用	原因
方法需要修改结构体	指针接收者	值接收者只能修改副本
结构体较大	指针接收者	避免复制大结构体
一致性原则	指针接收者	如果一个方法用指针，其他也应该用指针
只读操作、小结构体	值接收者	更安全，语义清晰
包含 sync.Mutex 等同步原语	指针接收者	这些类型不应复制

一致性原则：如果一个类型的任何方法使用了指针接收者，那么该类型的所有方法都应该使用指针接收者。这可以避免使用时产生混淆。

// 推荐：所有方法使用相同的接收者类型
type Counter struct {
    count int
}

// ✅ 全部使用指针接收者
func (c *Counter) Increment() { c.count++ }
func (c *Counter) Decrement() { c.count-- }
func (c *Counter) Value() int { return c.count }

// ❌ 混用会导致混淆
func (c Counter) Value() int { return c.count }  // 值接收者
func (c *Counter) Increment() { c.count++ }      // 指针接收者

自动引用和解引用

Go 会自动处理值和指针之间的转换，让方法调用更加方便：

rect := Rectangle{Width: 10, Height: 5}
rect.Scale(2)   // 值类型调用指针方法，自动取地址 (&rect).Scale(2)

pRect := &Rectangle{Width: 10, Height: 5}
fmt.Println(pRect.Area())  // 指针类型调用值方法，自动解引用 (*pRect).Area()

这种便利性仅限于变量和可寻址的值。对于不可寻址的值（如 map 元素），自动转换不会发生。

方法集（Method Sets）

方法集是 Go 类型系统中的核心概念，它决定了类型实现了哪些接口。

方法定义

根据 Go 语言规范，方法集的定义如下：

值类型 T 的方法集：包含所有接收者为 T 的方法
指针类型 *T 的方法集：包含所有接收者为 T 或 *T 的方法

换句话说，*T 的方法集是 T 的方法集的超集。

type List []int

// 值接收者方法
func (l List) Len() int {
    return len(l)
}

// 指针接收者方法
func (l *List) Append(val int) {
    *l = append(*l, val)
}

这个类型的方法集：

List   的方法集: { Len }
*List  的方法集: { Len, Append }

方法集与接口实现

方法集的重要性在于它决定了类型是否实现了某个接口。只有当类型的方法集包含了接口的所有方法时，该类型才实现了该接口。

type Appender interface {
    Append(int)
}

type Lener interface {
    Len() int
}

func main() {
    var lst List
    
    // List 的方法集只有 Len，所以：
    var _ Lener = lst    // ✅ 编译通过
    // var _ Appender = lst  // ❌ 编译错误：List 没有 Append 方法
    
    var plst *List
    // *List 的方法集包含 Len 和 Append，所以：
    var _ Lener = plst   // ✅ 编译通过
    var _ Appender = plst // ✅ 编译通过
}

关键点：虽然你可以在值类型上调用指针方法（Go 会自动取地址），但当涉及到接口时，方法集的规则是严格的。只有指针类型 *T 的方法集才包含指针接收者方法。

变量 vs 接口的方法调用

这是初学者容易困惑的地方。看下面的例子：

func main() {
    var lst List
    lst.Append(1)  // ✅ 可以调用！Go 自动转换为 (&lst).Append(1)
    
    var _ Appender = lst  // ❌ 编译错误！
}

为什么 lst.Append(1) 可以调用，但 lst 不能赋值给 Appender 接口？

原因在于：

方法调用：如果 x 是可寻址的，且 &x 的方法集包含方法 m，那么 x.m() 是合法的，编译器会自动转换为 (&x).m()
接口赋值：接口赋值时不会进行这种转换。存储在接口中的值是不可寻址的，所以必须类型完全匹配

不同场景下的方法调用规则

场景	值方法	指针方法	原因
普通变量 `T`	✅	✅（自动取地址）	变量可寻址
指针变量 `*T`	✅（自动解引用）	✅	指针可以解引用
切片元素 `[]T[i]`	✅	✅	切片元素可寻址
Map 元素 `map[K]T[k]`	✅	❌	Map 元素不可寻址
接口变量 `interface{}`	✅	❌（仅值类型）	接口内值不可寻址

Map 元素的特殊情况：

lists := map[string]List{
    "a": {1, 2, 3},
}

lists["a"].Len()      // ✅ 值方法可以调用
// lists["a"].Append(4)  // ❌ 编译错误：Map 元素不可寻址

// 解决方案：使用指针元素
listPtrs := map[string]*List{
    "a": &List{1, 2, 3},
}
listPtrs["a"].Append(4)  // ✅ 指针元素可以调用指针方法

最佳实践：如果类型有指针接收者方法，存储到 Map 或接口时应该使用指针类型。

// 推荐：使用指针
m := map[string]*List{}

// 不推荐：使用值（无法调用指针方法）
m := map[string]List{}

结构体嵌套

匿名嵌套

type Address struct {
    City  string
    State string
}

type Person struct {
    Name    string
    Address // 匿名嵌套
}

p := Person{
    Name: "张三",
    Address: Address{
        City:  "北京",
        State: "北京",
    },
}

// 可以直接访问嵌套字段
fmt.Println(p.City)      // 北京
fmt.Println(p.Address.City) // 北京

命名嵌套

type Address struct {
    City  string
    State string
}

type Person struct {
    Name    string
    Home   Address // 命名嵌套
    Work   Address
}

p := Person{
    Name: "张三",
    Home: Address{City: "北京", State: "北京"},
    Work: Address{City: "上海", State: "上海"},
}

多层嵌套

type Country struct {
    Name string
}

type Province struct {
    Country Country
    Name    string
}

type City struct {
    Province Province
    Name     string
}

c := City{
    Province: Province{
        Country: Country{Name: "中国"},
        Name:    "四川",
    },
    Name: "成都",
}

fmt.Println(c.Province.Country.Name) // 中国

嵌入字段的方法提升

嵌入字段的一个重要特性是方法提升（method promotion）。当一个类型被嵌入到结构体中时，该类型的方法会被"提升"到外层结构体，可以直接调用。

基本规则

type Animal struct {
    Name string
}

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

func (a Animal) GetName() string {
    return a.Name
}

type Dog struct {
    Animal  // 嵌入 Animal
    Breed string
}

func main() {
    d := Dog{
        Animal: Animal{Name: "旺财"},
        Breed:  "金毛",
    }
    
    // 方法提升：可以直接调用嵌入类型的方法
    fmt.Println(d.Speak())     // "..."
    fmt.Println(d.GetName())   // "旺财"
    
    // 也可以通过嵌入字段显式调用
    fmt.Println(d.Animal.Speak())   // "..."
}

方法覆盖

如果外层结构体定义了同名方法，外层方法会覆盖嵌入类型的方法：

func (d Dog) Speak() string {
    return "汪汪汪"
}

func main() {
    d := Dog{Animal: Animal{Name: "旺财"}}
    
    fmt.Println(d.Speak())         // "汪汪汪"（Dog 的方法）
    fmt.Println(d.Animal.Speak())  // "..."（仍然可以访问嵌入类型的方法）
}

指针嵌入

嵌入指针类型时，方法同样会被提升：

type Engine struct {
    Power int
}

func (e *Engine) Start() {
    fmt.Println("引擎启动")
}

type Car struct {
    *Engine  // 嵌入指针
    Brand string
}

func main() {
    c := Car{
        Engine: &Engine{Power: 200},
        Brand:  "Toyota",
    }
    
    c.Start()  // 方法提升，可以直接调用
}

注意：嵌入指针时，必须确保指针不为 nil，否则调用方法会导致 panic。

嵌入接口

接口也可以被嵌入到结构体中，这是一种常见的解耦模式：

type Store interface {
    Save(data string) error
    Load(key string) (string, error)
}

type Service struct {
    Store  // 嵌入接口
    Name string
}

func (s *Service) Process(data string) error {
    // 直接调用嵌入接口的方法
    return s.Save(data)
}

嵌入接口使得 Service 必须持有一个实现了 Store 接口的具体类型才能工作：

type MemoryStore struct {
    data map[string]string
}

func (m *MemoryStore) Save(data string) error {
    m.data["key"] = data
    return nil
}

func (m *MemoryStore) Load(key string) (string, error) {
    return m.data[key], nil
}

func main() {
    s := &Service{
        Store: &MemoryStore{data: make(map[string]string)},
        Name:  "MyService",
    }
    s.Process("hello")
}

方法提升的详细规则

根据 Go 语言规范，方法提升遵循以下规则：

字段提升：嵌入类型的字段可以直接访问
方法提升：嵌入类型的方法可以直接调用
冲突处理：如果两个嵌入类型有同名字段或方法，必须显式指定
遮蔽规则：外层类型定义的字段或方法会遮蔽嵌入类型的同名成员

type A struct {
    X int
}

func (a A) Method() string { return "A" }

type B struct {
    X int
}

func (b B) Method() string { return "B" }

type C struct {
    A
    B
}

func main() {
    c := C{A: A{X: 1}, B: B{X: 2}}
    
    // c.X      // 编译错误：ambiguous selector c.X
    c.A.X       // 必须显式指定
    c.B.X
    
    // c.Method()  // 编译错误：ambiguous selector
    c.A.Method()  // 必须显式指定
    c.B.Method()
}

组合 vs 继承

Go 的嵌入机制不同于传统面向对象语言中的继承：

type Base struct{}

func (b *Base) Method() { fmt.Println("Base") }

type Derived struct {
    Base
}

// Derived 不是 Base 的子类型
// 不能将 *Derived 赋值给 *Base 类型的变量

func main() {
    d := Derived{}
    d.Method()  // 输出 "Base"
    
    // var b *Base = &d  // 编译错误
}

嵌入是组合而非继承。这种方法提供了更大的灵活性，避免了继承层次带来的复杂性。

结构体相等性

可比较的结构体

如果结构体的所有字段都是可比较的，结构体也可以比较：

type Point struct {
    X int
    Y int
}

p1 := Point{X: 1, Y: 2}
p2 := Point{X: 1, Y: 2}
p3 := Point{X: 2, Y: 1}

fmt.Println(p1 == p2) // true
fmt.Println(p1 == p3) // false

不可比较的结构体

包含切片、映射、函数的结构体不能比较：

type Person struct {
    Name string
    hobbies []string // 切片，不可比较
}

// ❌ 编译错误
// fmt.Println(p1 == p2)

深拷贝与浅拷贝

理解结构体的复制行为对于编写正确的程序至关重要。在 Go 中，赋值操作总是进行值复制，但复制的内容取决于字段的类型。

值类型与引用类型字段

type Data struct {
    Value int
    Slice []int
    Map   map[string]int
}

func main() {
    original := Data{
        Value: 10,
        Slice: []int{1, 2, 3},
        Map:    map[string]int{"a": 1},
    }
    
    // 浅拷贝：直接赋值
    copy := original
    
    // 值类型字段：完全独立的副本
    copy.Value = 20
    fmt.Println(original.Value)  // 10（不受影响）
    
    // 引用类型字段：共享底层数据
    copy.Slice[0] = 100
    fmt.Println(original.Slice[0])  // 100（被影响了！）
    
    copy.Map["b"] = 2
    fmt.Println(original.Map["b"])  // 2（被影响了！）
}

深拷贝的实现方式

当需要完全独立的副本时，需要进行深拷贝。

方法一：手动复制

func (d Data) DeepCopy() Data {
    // 创建新的切片
    newSlice := make([]int, len(d.Slice))
    copy(newSlice, d.Slice)
    
    // 创建新的 map
    newMap := make(map[string]int, len(d.Map))
    for k, v := range d.Map {
        newMap[k] = v
    }
    
    return Data{
        Value: d.Value,
        Slice: newSlice,
        Map:   newMap,
    }
}

方法二：使用 JSON 序列化

import (
    "encoding/json"
    "reflect"
)

func deepCopyJSON(v interface{}) (interface{}, error) {
    data, err := json.Marshal(v)
    if err != nil {
        return nil, err
    }
    
    // 创建新实例
    newValue := reflect.New(reflect.TypeOf(v)).Interface()
    err = json.Unmarshal(data, newValue)
    if err != nil {
        return nil, err
    }
    
    return reflect.ValueOf(newValue).Elem().Interface(), nil
}

// 简化版本（已知类型）
func deepCopyJSONSimple(d Data) (Data, error) {
    data, err := json.Marshal(d)
    if err != nil {
        return Data{}, err
    }
    
    var result Data
    err = json.Unmarshal(data, &result)
    return result, err
}

注意：JSON 方式有局限性，无法处理非 JSON 兼容类型（如 chan、func、complex128 等）。

方法三：使用 gob 编码

import (
    "bytes"
    "encoding/gob"
)

func deepCopyGob(dst, src interface{}) error {
    var buf bytes.Buffer
    encoder := gob.NewEncoder(&buf)
    if err := encoder.Encode(src); err != nil {
        return err
    }
    
    decoder := gob.NewDecoder(&buf)
    return decoder.Decode(dst)
}

// 使用
var copy Data
err := deepCopyGob(&copy, original)

结构体嵌套时的拷贝

当结构体包含嵌套结构体时，需要考虑每一层是否需要深拷贝：

type Inner struct {
    Data []int
}

type Outer struct {
    Name  string
    Inner Inner
}

func (o Outer) DeepCopy() Outer {
    return Outer{
        Name: o.Name,
        Inner: Inner{
            Data: append([]int{}, o.Inner.Data...),
        },
    }
}

浅拷贝的适用场景

浅拷贝并非总是问题，有些场景下浅拷贝是合适的：

// 只读数据：不需要深拷贝
type Config struct {
    Timeout time.Duration
    Retries int
}

// 数据量大且不需要修改
type ReadOnlyCache struct {
    Data *LargeData
}

// 通过指针共享数据是预期行为
func processSharedData(data *LargeData) {
    // 多个 goroutine 可以安全读取
}

最佳实践

优先考虑值语义：设计结构体时，尽量使用值类型字段
明确复制语义：如果需要深拷贝，提供 DeepCopy 或 Clone 方法
文档说明：在文档中明确说明结构体的复制行为
避免意外共享：使用指针时要意识到数据可能被共享

JSON 序列化

基本序列化

import "encoding/json"

type Person struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
    City string `json:"city,omitempty"` // 空值省略
}

p := Person{Name: "张三", Age: 25}

// 序列化为 JSON
data, err := json.Marshal(p)
fmt.Println(string(data))
// {"name":"张三","age":25,"city":""}

// 格式化输出
data, _ = json.MarshalIndent(p, "", "  ")
fmt.Println(string(data))

反序列化

jsonStr := `{"name":"李四","age":30,"city":"上海"}`

var p Person
err := json.Unmarshal([]byte(jsonStr), &p)
fmt.Println(p.Name, p.Age, p.City) // 李四 30 上海

忽略字段

type Person struct {
    Name  string `json:"name"`
    Age   int    `json:"age"`
    password string `json:"-"` // 忽略此字段
}

构造函数

Go 没有内置构造函数，但可以创建工厂函数。构造函数的命名通常以 New 开头，如果是包的唯一导出类型，可以直接命名为 New。

基本构造函数

type Person struct {
    Name string
    Age  int
}

// 构造函数：返回指针
func NewPerson(name string, age int) *Person {
    return &Person{
        Name: name,
        Age:  age,
    }
}

// 使用
p := NewPerson("张三", 25)

多构造函数

当需要不同的初始化方式时，可以通过函数名区分：

type Person struct {
    Name  string
    Age   int
    Email string
}

// 基本构造函数
func NewPerson(name string, age int) *Person {
    return &Person{Name: name, Age: age}
}

// 带邮箱的构造函数
func NewPersonWithEmail(name string, age int, email string) *Person {
    return &Person{Name: name, Age: age, Email: email}
}

// 默认构造函数
func NewDefaultPerson() *Person {
    return &Person{Name: "匿名", Age: 0}
}

函数式选项模式

当结构体有很多可选配置时，使用多个构造函数会导致组合爆炸。函数式选项模式是解决这个问题的经典方案，在 Go 标准库和流行框架中广泛使用：

type Server struct {
    host     string
    port     int
    timeout  time.Duration
    maxConns int
    tls      bool
    certFile string
    keyFile  string
}

// Option 定义选项函数类型
type Option func(*Server)

// 选项函数：设置端口
func WithPort(port int) Option {
    return func(s *Server) {
        s.port = port
    }
}

// 选项函数：设置超时
func WithTimeout(timeout time.Duration) Option {
    return func(s *Server) {
        s.timeout = timeout
    }
}

// 选项函数：启用 TLS
func WithTLS(certFile, keyFile string) Option {
    return func(s *Server) {
        s.tls = true
        s.certFile = certFile
        s.keyFile = keyFile
    }
}

// 选项函数：设置最大连接数
func WithMaxConnections(max int) Option {
    return func(s *Server) {
        s.maxConns = max
    }
}

// 构造函数：必填参数 + 可选配置
func NewServer(host string, opts ...Option) *Server {
    // 设置默认值
    server := &Server{
        host:     host,
        port:     8080,              // 默认端口
        timeout:  30 * time.Second,  // 默认超时
        maxConns: 100,               // 默认最大连接数
    }
    
    // 应用选项
    for _, opt := range opts {
        opt(server)
    }
    
    return server
}

// 使用示例
func main() {
    // 只使用默认值
    s1 := NewServer("localhost")
    
    // 自定义部分选项
    s2 := NewServer("localhost",
        WithPort(9000),
        WithTimeout(60*time.Second),
    )
    
    // 启用 TLS
    s3 := NewServer("localhost",
        WithPort(443),
        WithTLS("cert.pem", "key.pem"),
        WithMaxConnections(1000),
    )
}

这个模式的优势在于：

API 清晰：选项名有明确的语义
向后兼容：添加新选项不影响现有代码
默认值明确：在构造函数中统一设置
灵活组合：可以任意组合选项

配置结构体模式

另一种处理复杂配置的方式是使用配置结构体：

type ServerConfig struct {
    Host     string        // 必填
    Port     int           // 可选，默认 8080
    Timeout  time.Duration // 可选，默认 30s
    MaxConns int           // 可选，默认 100
}

func NewServer(cfg ServerConfig) *Server {
    // 设置默认值
    if cfg.Port == 0 {
        cfg.Port = 8080
    }
    if cfg.Timeout == 0 {
        cfg.Timeout = 30 * time.Second
    }
    if cfg.MaxConns == 0 {
        cfg.MaxConns = 100
    }
    
    return &Server{
        host:     cfg.Host,
        port:     cfg.Port,
        timeout:  cfg.Timeout,
        maxConns: cfg.MaxConns,
    }
}

// 使用
s := NewServer(ServerConfig{
    Host:     "localhost",
    Port:     9000,
    MaxConns: 500,
})

两种模式各有优缺点：函数式选项模式更灵活、更易扩展，配置结构体模式更直观、IDE 支持更好。根据项目需求选择合适的方案。

组合与继承

组合模式

type Animal struct {
    Name string
}

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

type Dog struct {
    Animal       // 嵌入
    Breed string
}

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

d := Dog{
    Animal: Animal{Name: "旺财"},
    Breed: "金毛",
}

d.Speak()       // 汪汪汪（自己定义的）
d.Animal.Speak() // ...（嵌入的）

接口组合

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

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

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

方法表达式与方法值

Go 提供了两种将方法作为函数值使用的方式：方法表达式和方法值。理解它们的区别对于编写灵活的代码非常重要。

方法表达式

方法表达式是将方法从类型中"提取"出来，作为一个独立的函数使用。语法形式为 Type.Method，此时接收者成为函数的第一个参数。

type Rectangle struct {
    Width  float64
    Height float64
}

func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}

func (r *Rectangle) Scale(factor float64) {
    r.Width *= factor
    r.Height *= factor
}

func main() {
    rect := Rectangle{Width: 10, Height: 5}
    
    // 方法表达式：将方法作为函数使用
    // 接收者作为第一个参数传入
    areaFunc := Rectangle.Area
    fmt.Println(areaFunc(rect))  // 50
    
    // 指针接收者的方法表达式
    scaleFunc := (*Rectangle).Scale
    scaleFunc(&rect, 2)
    fmt.Println(rect.Area())  // 200
    
    // 可以用于实现类似"模板方法"的模式
    shapes := []Rectangle{
        {Width: 10, Height: 5},
        {Width: 3, Height: 4},
        {Width: 6, Height: 8},
    }
    
    // 使用方法表达式计算所有形状的面积
    for _, s := range shapes {
        fmt.Println(Rectangle.Area(s))
    }
}

关键点：

方法表达式 Type.Method 的类型是一个函数，接收者作为第一个参数
值类型的方法表达式 Rectangle.Area 接收 Rectangle 类型的参数
指针类型的方法表达式 (*Rectangle).Scale 接收 *Rectangle 类型的参数

方法值

方法值是将方法绑定到特定的接收者实例，形成一个闭包。语法形式为 instance.Method，不需要再传递接收者。

func main() {
    rect := Rectangle{Width: 10, Height: 5}
    
    // 方法值：方法绑定到特定实例
    areaFunc := rect.Area
    fmt.Println(areaFunc())  // 50
    
    // 方法值捕获了接收者的副本（值接收者）
    rect.Width = 20
    fmt.Println(areaFunc())  // 仍然是 50，因为捕获的是副本
    
    // 指针接收者的方法值
    scaleFunc := rect.Scale
    scaleFunc(2)  // 修改原结构体
    fmt.Println(rect.Area())  // 200
    
    // 方法值的实际应用：作为回调函数
    numbers := []int{1, 2, 3, 4, 5}
    var result []float64
    
    // 假设有一个处理函数需要回调
    process := func(n int, transform func(int) float64) {
        result = append(result, transform(n))
    }
    
    // 使用方法值
    converter := Converter{Multiplier: 2.5}
    for _, n := range numbers {
        process(n, converter.Convert)  // 方法值作为回调
    }
}

type Converter struct {
    Multiplier float64
}

func (c Converter) Convert(n int) float64 {
    return float64(n) * c.Multiplier
}

方法值捕获规则：

值接收者的方法值会捕获接收者的副本，后续修改原实例不影响方法值
指针接收者的方法值会捕获指针，修改原实例会影响方法值的行为

两者的区别

特性	方法表达式 `Type.Method`	方法值 `instance.Method`
形式	函数	闭包
接收者	作为第一个参数传入	已绑定，无需传入
类型	`func(T, ...) ReturnType`	`func(...) ReturnType`
用途	需要灵活选择接收者	已确定接收者的场景

空结构体

空结构体 struct{} 是 Go 中一个特殊的类型，它不占用任何内存空间。这个特性使它在特定场景下非常有用。

零内存占用

var s struct{}
fmt.Println(unsafe.Sizeof(s))  // 0

// 对比其他类型
fmt.Println(unsafe.Sizeof(0))     // 8 (int)
fmt.Println(unsafe.Sizeof(""))    // 16 (string header)
fmt.Println(unsafe.Sizeof(false)) // 1 (bool)

实现集合（Set）

空结构体最常见的用途是实现集合，因为 map 的值类型使用 struct{} 不占用额外空间：

type Set map[string]struct{}

func NewSet(items ...string) Set {
    s := make(Set)
    for _, item := range items {
        s[item] = struct{}{}
    }
    return s
}

func (s Set) Add(item string) {
    s[item] = struct{}{}
}

func (s Set) Remove(item string) {
    delete(s, item)
}

func (s Set) Contains(item string) bool {
    _, exists := s[item]
    return exists
}

func main() {
    set := NewSet("apple", "banana", "cherry")
    set.Add("date")
    
    fmt.Println(set.Contains("apple"))   // true
    fmt.Println(set.Contains("grape"))   // false
    
    // 遍历集合
    for item := range set {
        fmt.Println(item)
    }
}

通道信号

空结构体常用于通道信号，表示"事件发生"而不传递数据：

func main() {
    done := make(chan struct{})
    
    go func() {
        time.Sleep(time.Second)
        fmt.Println("工作完成")
        close(done)  // 发送完成信号
    }()
    
    <-done  // 等待完成信号
    fmt.Println("收到完成信号")
}

单例模式

type Singleton struct{}

var (
    instance *Singleton
    once     sync.Once
)

func GetInstance() *Singleton {
    once.Do(func() {
        instance = &Singleton{}
    })
    return instance
}

// 空结构体实例只占用指针大小（8字节）
// 如果 Singleton 有字段，则会占用更多空间

接口实现

空结构体可以用于实现接口，创建"无状态"的实现：

type Handler interface {
    Handle(data string)
}

type NopHandler struct{}

func (NopHandler) Handle(data string) {
    // 什么都不做
}

type LoggingHandler struct{}

func (LoggingHandler) Handle(data string) {
    log.Println(data)
}

func process(handler Handler, data string) {
    handler.Handle(data)
}

nil 接收者

Go 允许在 nil 指针上调用方法，这是一个强大但容易被忽略的特性。

nil 接收者的行为

type IntTree struct {
    val         int
    left, right *IntTree
}

func (it *IntTree) Insert(val int) *IntTree {
    if it == nil {
        return &IntTree{val: val}
    }
    if val < it.val {
        it.left = it.left.Insert(val)
    } else if val > it.val {
        it.right = it.right.Insert(val)
    }
    return it
}

func (it *IntTree) Contains(val int) bool {
    switch {
    case it == nil:
        return false
    case val < it.val:
        return it.left.Contains(val)
    case val > it.val:
        return it.right.Contains(val)
    default:
        return true
    }
}

func main() {
    var root *IntTree  // nil
    
    // 在 nil 上调用方法！
    root = root.Insert(5)
    root = root.Insert(3)
    root = root.Insert(7)
    
    fmt.Println(root.Contains(5))  // true
    fmt.Println(root.Contains(4))  // false
}

关键点：方法可以检查接收者是否为 nil，并做出适当的处理。

值接收者与 nil

值接收者的方法不能在 nil 上调用，因为 nil 无法解引用：

type Counter struct {
    value int
}

// 值接收者方法
func (c Counter) Value() int {
    return c.value
}

func main() {
    var c *Counter  // nil
    
    // ❌ 运行时 panic
    // c.Value()  // panic: value method Counter.Value called using nil pointer
    
    // ✅ 正确做法：先检查 nil
    if c != nil {
        fmt.Println(c.Value())
    }
}

接口中的 nil

接口值为 nil 和接口包含 nil 值是不同的概念：

func describe(i interface{}) {
    fmt.Printf("值: %v, 类型: %T\n", i, i)
}

func main() {
    var p *int  // nil
    describe(p)  // 值: <nil>, 类型: *int
    
    var i interface{}  // nil 接口
    describe(i)  // 值: <nil>, 类型: <nil>
    
    // 将 nil 指针赋给接口
    var p2 *int
    var i2 interface{} = p2
    describe(i2)  // 值: <nil>, 类型: *int
    
    // 此时 i2 != nil！
    fmt.Println(i2 == nil)  // false
}

最佳实践

type SafeSlice []int

func (s SafeSlice) Get(index int) (int, error) {
    if s == nil {
        return 0, errors.New("slice is nil")
    }
    if index < 0 || index >= len(s) {
        return 0, errors.New("index out of range")
    }
    return s[index], nil
}

func (s *SafeSlice) Append(values ...int) {
    if s == nil {
        return  // 或者创建新切片
    }
    *s = append(*s, values...)
}

结构体标签详解

结构体标签（struct tag）是附加在字段上的元数据，通过反射机制读取。除了 JSON 标签，还有许多其他用途。

标签语法

type Person struct {
    Name string `json:"name" xml:"name" db:"name" validate:"required,min=2,max=50"`
    Age  int    `json:"age" xml:"age" db:"age" validate:"min=0,max=150"`
}

标签格式：`key1:"value1" key2:"value2"`

常用标签

标签	用途	示例
`json`	JSON 序列化/反序列化	`json:"name,omitempty"`
`xml`	XML 序列化/反序列化	`xml:"name,attr"`
`yaml`	YAML 序列化/反序列化	`yaml:"name"`
`db`	数据库映射（sqlx, gorp）	`db:"user_name"`
`gorm`	GORM ORM 标签	`gorm:"column:name;type:varchar(100)"`
`validate`	输入验证	`validate:"required,email"`
`form`	表单绑定	`form:"username"`
`binding`	Gin 框架绑定	`binding:"required"`
`mapstructure`	配置解析	`mapstructure:"server_port"`

读取标签

使用 reflect 包读取结构体标签：

import "reflect"

type User struct {
    Name string `json:"name" validate:"required"`
    Age  int    `json:"age" validate:"min=0"`
}

func inspectTags(v interface{}) {
    t := reflect.TypeOf(v)
    
    for i := 0; i < t.NumField(); i++ {
        field := t.Field(i)
        fmt.Printf("字段: %s\n", field.Name)
        fmt.Printf("  json: %s\n", field.Tag.Get("json"))
        fmt.Printf("  validate: %s\n", field.Tag.Get("validate"))
    }
}

func main() {
    inspectTags(User{})
    // 输出：
    // 字段: Name
    //   json: name
    //   validate: required
    // 字段: Age
    //   json: age
    //   validate: min=0
}

JSON 标签详解

type Product struct {
    // 基本用法：指定字段名
    Name string `json:"name"`
    
    // omitempty：零值时省略该字段
    Price float64 `json:"price,omitempty"`
    
    // -：完全忽略该字段
    secret string `json:"-"`
    
    // string：数字转字符串输出
    ID int64 `json:"id,string"`
    
    // 嵌套结构体的处理
    Category struct {
        ID   int    `json:"id"`
        Name string `json:"name"`
    } `json:"category"`
}

自定义标签处理

// 自定义验证器
func Validate(v interface{}) error {
    val := reflect.ValueOf(v)
    if val.Kind() == reflect.Ptr {
        val = val.Elem()
    }
    typ := val.Type()
    
    for i := 0; i < typ.NumField(); i++ {
        field := typ.Field(i)
        fieldValue := val.Field(i)
        tag := field.Tag.Get("validate")
        
        if tag == "" {
            continue
        }
        
        if strings.Contains(tag, "required") {
            if fieldValue.IsZero() {
                return fmt.Errorf("%s is required", field.Name)
            }
        }
    }
    return nil
}

小结

本章详细介绍了 Go 语言中结构体和方法的核心概念：

结构体基础：自定义复合类型，字段定义、实例化方式、零值机制
零值可用设计原则：设计结构体时让零值有意义，可直接使用
内存布局：连续存储、内存对齐与填充、优化字段顺序减少内存占用
方法：值接收者与指针接收者的区别、选择原则、自动解引用
方法集：决定接口实现的关键概念，值类型和指针类型的方法集差异
结构体嵌套：匿名嵌套实现字段提升、命名嵌套、多层嵌套、方法提升规则
结构体比较：可比较与不可比较的结构体
深拷贝与浅拷贝：理解复制行为，实现深拷贝的多种方式
JSON 序列化：结构体标签控制序列化行为
构造函数：工厂函数模式、函数式选项模式、配置结构体模式
组合与继承：通过嵌入实现类似继承的效果，组合优于继承
方法表达式与方法值：将方法作为函数值使用的两种方式
空结构体：零内存占用的特殊类型，用于集合、信号等场景
nil 接收者：在 nil 指针上调用方法的行为和处理方式
结构体标签：元数据机制，支持 JSON、XML、数据库映射等多种用途

练习

定义一个矩形结构体，实现面积和周长计算方法
创建一个学生结构体，包含姓名、年龄和多门课程成绩
给学生结构体添加计算平均成绩的方法
实现一个 Person 结构体的 JSON 序列化
使用嵌套结构体创建公司组织结构
实现一个支持函数式选项模式的 Server 配置结构体
编写一个深拷贝函数，处理包含切片和 map 的结构体

结构体基础​

什么是结构体​

结构体定义语法​

创建结构体实例​

访问和修改字段​

零值可用设计原则​

零值的意义​

设计零值可用的结构体​

避免零值陷阱​

零值传递性​

零值与构造函数​

结构体内存布局​

内存连续存储​

内存对齐与填充​

使用 unsafe.Offsetof 查看字段偏移​

方法​

方法的本质​

值接收者与指针接收者​

如何选择接收者类型​

自动引用和解引用​

方法集（Method Sets）​

方法定义​

方法集与接口实现​

变量 vs 接口的方法调用​

不同场景下的方法调用规则​

结构体嵌套​

匿名嵌套​

命名嵌套​

多层嵌套​

嵌入字段的方法提升​

基本规则​

方法覆盖​

指针嵌入​

嵌入接口​

方法提升的详细规则​

组合 vs 继承​

结构体相等性​

可比较的结构体​

不可比较的结构体​

深拷贝与浅拷贝​

值类型与引用类型字段​

深拷贝的实现方式​

方法一：手动复制​

方法二：使用 JSON 序列化​

方法三：使用 gob 编码​

结构体嵌套时的拷贝​

浅拷贝的适用场景​

最佳实践​

JSON 序列化​

基本序列化​

反序列化​

忽略字段​

构造函数​

基本构造函数​

多构造函数​

函数式选项模式​

配置结构体模式​

组合与继承​

组合模式​

接口组合​

方法表达式与方法值​

方法表达式​

方法值​

两者的区别​

空结构体​

零内存占用​

实现集合（Set）​

通道信号​

单例模式​

接口实现​

nil 接收者​

nil 接收者的行为​

值接收者与 nil​

接口中的 nil​

最佳实践​

结构体标签详解​

标签语法​

常用标签​

读取标签​

JSON 标签详解​

结构体基础

什么是结构体

结构体定义语法

创建结构体实例

访问和修改字段

零值可用设计原则

零值的意义

设计零值可用的结构体

避免零值陷阱

零值传递性

零值与构造函数

结构体内存布局

内存连续存储

内存对齐与填充

使用 unsafe.Offsetof 查看字段偏移

方法

方法的本质

值接收者与指针接收者

如何选择接收者类型

自动引用和解引用

方法集（Method Sets）

方法定义

方法集与接口实现

变量 vs 接口的方法调用

不同场景下的方法调用规则

结构体嵌套

匿名嵌套

命名嵌套

多层嵌套

嵌入字段的方法提升

基本规则

方法覆盖

指针嵌入

嵌入接口

方法提升的详细规则

组合 vs 继承

结构体相等性

可比较的结构体

不可比较的结构体

深拷贝与浅拷贝

值类型与引用类型字段

深拷贝的实现方式

方法一：手动复制

方法二：使用 JSON 序列化

方法三：使用 gob 编码

结构体嵌套时的拷贝

浅拷贝的适用场景

最佳实践

JSON 序列化

基本序列化

反序列化

忽略字段

构造函数

基本构造函数

多构造函数

函数式选项模式

配置结构体模式

组合与继承

组合模式

接口组合

方法表达式与方法值

方法表达式

方法值

两者的区别

空结构体

零内存占用

实现集合（Set）

通道信号

单例模式

接口实现

nil 接收者

nil 接收者的行为

值接收者与 nil

接口中的 nil

最佳实践

结构体标签详解

标签语法

常用标签

读取标签

JSON 标签详解