Go 语言结构体（深入浅出）

Go 语言结构体：构建复杂数据的基石

在 Go 语言中，结构体（struct）是一种自定义的数据类型，它允许我们将多个不同类型的数据组合成一个整体。你可以把它想象成一个“数据盒子”——这个盒子可以装各种不同的东西，比如名字、年龄、地址、成绩等，而这些信息都被封装在同一个结构里，方便管理和使用。

如果你熟悉 Java 或 C++，那么结构体的概念并不陌生。但在 Go 中，它更轻量、更灵活，是构建复杂数据模型的核心工具。尤其在处理用户信息、配置文件、网络请求体等场景时，Go 语言结构体几乎无处不在。

什么是 Go 语言结构体？

Go 语言结构体是用户自定义的一种复合类型，它将多个字段（field）组合在一起，形成一个逻辑单元。每个字段可以是不同的数据类型，比如字符串、整数、布尔值，甚至其他结构体。

举个例子：我们要表示一个学生的信息，包含姓名、年龄、成绩和是否在读。用结构体来表示就非常清晰：

type Student struct {
    Name   string
    Age    int
    Score  float64
    Active bool
}

这段代码定义了一个名为 Student 的结构体类型，它有四个字段：

Name：学生姓名，类型为 string
Age：年龄，类型为 int
Score：成绩，类型为 float64
Active：是否在读，类型为 bool

注意：字段名首字母大写表示可导出（exported），可以在包外访问；小写则为私有（unexported），只能在当前包内使用。

创建与初始化结构体

定义了结构体类型后，下一步就是创建实例。Go 提供了多种方式来初始化结构体，最常用的是字面量写法。

使用字面量直接初始化

// 创建一个 Student 实例
student := Student{
    Name:   "张三",
    Age:    20,
    Score:  88.5,
    Active: true,
}

这种方式清晰、可读性强，尤其适合字段较多的情况。你还可以省略字段名，但必须按定义顺序填写值：

student := Student{"李四", 21, 92.0, false}

⚠️ 注意：这种顺序初始化方式容易出错，尤其是字段多或顺序变动时，建议优先使用带字段名的写法。

使用 new 关键字创建

// new 返回一个指向结构体的指针
studentPtr := new(Student)
studentPtr.Name = "王五"
studentPtr.Age = 19
studentPtr.Score = 95.5
studentPtr.Active = true

new(Student) 会分配内存并返回一个 *Student 类型的指针，所有字段会被初始化为对应类型的零值（如 ""、0、false）。

这种方式适用于需要传入指针的场景，比如函数参数需要修改结构体内容时。

访问与修改结构体字段

一旦创建了结构体实例，就可以通过点号（.）来访问或修改字段。

// 访问字段
fmt.Println("学生姓名：", student.Name)
fmt.Println("年龄：", student.Age)

// 修改字段
student.Score = 90.0
student.Active = false

如果结构体是通过 new 创建的指针，访问方式也一样，Go 会自动进行指针解引用：

studentPtr := new(Student)
studentPtr.Name = "赵六"
fmt.Println(studentPtr.Name) // 输出：赵六

这使得指针和值类型的使用在语法上保持一致，降低了学习成本。

结构体作为函数参数

在 Go 中，函数参数传递有两种方式：值传递和指针传递。结构体默认是值传递，这意味着函数内部会收到一份副本。

值传递：副本拷贝

func updateStudent(s Student) {
    s.Name = "更新后的名字"
    fmt.Println("函数内修改：", s.Name)
}

func main() {
    student := Student{Name: "原名字"}
    updateStudent(student)
    fmt.Println("函数外：", student.Name) // 输出：原名字
}

可以看到，函数内修改了 Name，但外部的 student 并没有改变。这是因为 Go 传的是副本。

指针传递：直接修改原数据

如果希望函数能修改原始结构体，应该传入指针：

func updateStudentPtr(s *Student) {
    s.Name = "修改后的名字"
    fmt.Println("函数内修改：", s.Name)
}

func main() {
    student := Student{Name: "原名字"}
    updateStudentPtr(&student)
    fmt.Println("函数外：", student.Name) // 输出：修改后的名字
}

这里我们使用 &student 取地址，传入 *Student 类型的参数。函数内部通过 s.Name 直接修改原始数据。

✅ 建议：如果结构体较大（如包含大量字段或大数组），使用指针传递更高效，避免不必要的内存拷贝。

结构体嵌套与匿名字段

Go 语言支持结构体嵌套，即一个结构体可以包含另一个结构体作为字段。这在构建层级化数据模型时非常有用。

嵌套结构体

type Address struct {
    City  string
    Zip   string
}

type Person struct {
    Name   string
    Age    int
    Addr   Address // 嵌套结构体
}

func main() {
    person := Person{
        Name: "小明",
        Age:  25,
        Addr: Address{
            City: "北京",
            Zip:  "100000",
        },
    }

    fmt.Println("城市：", person.Addr.City)
}

通过 person.Addr.City，我们可以访问嵌套结构体的字段。这种写法让数据结构更有层次感。

匿名字段：提升访问便利性

如果结构体中只有一个字段，且没有命名，可以使用匿名字段：

type Person struct {
    string // 匿名字段：类型为 string
    int    // 匿名字段：类型为 int
}

func main() {
    person := Person{"Alice", 30}
    fmt.Println("姓名：", person.string) // 注意：字段名是类型名
    fmt.Println("年龄：", person.int)
}

⚠️ 注意：匿名字段的字段名就是其类型名（首字母大写），访问时必须用类型名，不能用 Name 或 Age 这样的名字。

结构体标签（Tag）与 JSON 序列化

在实际开发中，我们经常需要将结构体转换为 JSON 格式，比如在 API 接口返回数据时。

Go 提供了 struct tag 功能，允许我们在字段上添加元信息，用于控制序列化行为。

type User struct {
    ID    int    `json:"id"`
    Name  string `json:"name"`
    Email string `json:"email,omitempty"` // omitempty 表示为空时忽略
}

func main() {
    user := User{
        ID:    1,
        Name:  "张三",
        Email: "",
    }

    data, _ := json.Marshal(user)
    fmt.Println(string(data)) // 输出：{"id":1,"name":"张三"}
}

json:"id"：指定 JSON 中的键名为 id
omitempty：如果字段为空（如 ""、0、nil），则在 JSON 中省略该字段

这个功能在构建 Web 服务时极为关键，能够精确控制 API 输出格式。

结构体的比较与零值

Go 中的结构体支持直接比较（==），前提是所有字段都支持比较。

type Point struct {
    X, Y int
}

func main() {
    p1 := Point{1, 2}
    p2 := Point{1, 2}
    p3 := Point{1, 3}

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

✅ 但注意：如果结构体中包含不可比较的类型（如 map、slice、function），则整个结构体无法比较。

此外，结构体的零值是其所有字段的零值组合：

string → ""
int → 0
bool → false
struct → 所有字段为零值

这在初始化时非常有用，比如：

var emptyStudent Student // 所有字段为零值
fmt.Println(emptyStudent.Name) // 输出：空字符串

总结

Go 语言结构体是构建数据模型的基石。它不仅提供了清晰的字段组织方式，还通过值传递、指针传递、嵌套、标签等机制，满足了从简单数据封装到复杂系统设计的各种需求。

从学生信息到用户配置，从 API 响应到数据库映射，Go 语言结构体几乎贯穿整个 Go 应用开发流程。掌握它，就等于掌握了 Go 语言中“数据”这一核心要素。

无论是初学者还是中级开发者，都应该花时间理解结构体的特性与使用场景。它看似简单，实则蕴含了 Go 语言“简洁、高效、安全”的设计哲学。

当你在项目中看到 type User struct { ... } 时，不妨停下来思考：这个结构体代表了什么？它的字段如何组合？是否需要嵌套？是否要加 JSON 标签？

这些问题的答案，正是你提升 Go 编程能力的关键所在。