1.4.3 结构体基础 #

结构体（Struct）是 Go 语言中用于创建自定义数据类型的重要机制。它允许将不同类型的数据组合在一起，形成一个逻辑上相关的数据单元。结构体是 Go 语言面向对象编程的基础，也是构建复杂数据结构和业务模型的核心工具。

结构体的基本概念 #

什么是结构体 #

结构体是一种聚合数据类型，它将零个或多个任意类型的值聚合成一个实体。每个值称为结构体的字段（Field）或成员（Member）。结构体提供了一种将相关数据组织在一起的方式，使代码更加清晰和易于维护。

结构体的特点 #

值类型：结构体是值类型，赋值时会复制整个结构体
类型安全：编译时检查字段类型，避免运行时错误
内存连续：字段在内存中连续存储，访问效率高
可扩展：可以为结构体定义方法，实现面向对象编程

结构体的定义和声明 #

基本语法 #

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

定义结构体示例 #

package main

import "fmt"

// 定义一个简单的结构体
type Person struct {
    Name string
    Age  int
}

// 定义一个更复杂的结构体
type Student struct {
    ID       int
    Name     string
    Age      int
    Grade    string
    Scores   []float64
    IsActive bool
}

// 定义包含不同类型字段的结构体
type Book struct {
    Title       string
    Author      string
    Pages       int
    Price       float64
    PublishDate string
    ISBN        string
    InStock     bool
}

func main() {
    // 声明结构体变量
    var p Person
    fmt.Printf("零值结构体: %+v\n", p)

    var s Student
    fmt.Printf("学生零值: %+v\n", s)

    var b Book
    fmt.Printf("书籍零值: %+v\n", b)
}

结构体的零值 #

当声明一个结构体变量而不初始化时，它的所有字段都会被设置为对应类型的零值：

package main

import "fmt"

type Product struct {
    Name        string    // 零值: ""
    Price       float64   // 零值: 0.0
    Quantity    int       // 零值: 0
    Available   bool      // 零值: false
    Categories  []string  // 零值: nil
    Metadata    map[string]string // 零值: nil
}

func main() {
    var product Product

    fmt.Printf("产品名称: '%s'\n", product.Name)
    fmt.Printf("价格: %.2f\n", product.Price)
    fmt.Printf("数量: %d\n", product.Quantity)
    fmt.Printf("可用性: %t\n", product.Available)
    fmt.Printf("分类: %v\n", product.Categories)
    fmt.Printf("元数据: %v\n", product.Metadata)

    // 检查切片和映射是否为 nil
    if product.Categories == nil {
        fmt.Println("分类切片为 nil")
    }

    if product.Metadata == nil {
        fmt.Println("元数据映射为 nil")
    }
}

结构体的初始化 #

字面量初始化 #

package main

import "fmt"

type Address struct {
    Street   string
    City     string
    Province string
    PostCode string
    Country  string
}

type Employee struct {
    ID       int
    Name     string
    Email    string
    Salary   float64
    Address  Address
    Skills   []string
}

func main() {
    // 方式一：按字段顺序初始化
    addr1 := Address{
        "中山路123号",
        "南京",
        "江苏",
        "210000",
        "中国",
    }
    fmt.Printf("地址1: %+v\n", addr1)

    // 方式二：指定字段名初始化（推荐）
    addr2 := Address{
        Street:   "解放路456号",
        City:     "上海",
        Province: "上海",
        PostCode: "200000",
        Country:  "中国",
    }
    fmt.Printf("地址2: %+v\n", addr2)

    // 方式三：部分字段初始化
    addr3 := Address{
        City:    "北京",
        Country: "中国",
        // 其他字段使用零值
    }
    fmt.Printf("地址3: %+v\n", addr3)

    // 嵌套结构体初始化
    emp := Employee{
        ID:    1001,
        Name:  "张三",
        Email: "[email protected]",
        Salary: 8000.0,
        Address: Address{
            Street:   "天安门广场1号",
            City:     "北京",
            Province: "北京",
            PostCode: "100000",
            Country:  "中国",
        },
        Skills: []string{"Go", "Python", "JavaScript"},
    }
    fmt.Printf("员工信息: %+v\n", emp)
}

使用 new 函数 #

package main

import "fmt"

type Rectangle struct {
    Width  float64
    Height float64
}

func main() {
    // 使用 new 函数创建结构体指针
    rect1 := new(Rectangle)
    fmt.Printf("new 创建的结构体: %+v\n", rect1)
    fmt.Printf("结构体值: %+v\n", *rect1)

    // 为字段赋值
    rect1.Width = 10.5
    rect1.Height = 8.3
    fmt.Printf("赋值后: %+v\n", *rect1)

    // 等价的写法
    rect2 := &Rectangle{}
    rect2.Width = 15.0
    rect2.Height = 12.0
    fmt.Printf("等价写法: %+v\n", *rect2)

    // 直接初始化指针
    rect3 := &Rectangle{
        Width:  20.0,
        Height: 16.0,
    }
    fmt.Printf("直接初始化指针: %+v\n", *rect3)
}

结构体字段的访问 #

点操作符 #

package main

import "fmt"

type Car struct {
    Brand    string
    Model    string
    Year     int
    Price    float64
    Features []string
}

func main() {
    // 创建结构体实例
    car := Car{
        Brand: "Toyota",
        Model: "Camry",
        Year:  2023,
        Price: 25000.0,
        Features: []string{"自动驾驶", "倒车影像", "定速巡航"},
    }

    // 访问字段
    fmt.Printf("品牌: %s\n", car.Brand)
    fmt.Printf("型号: %s\n", car.Model)
    fmt.Printf("年份: %d\n", car.Year)
    fmt.Printf("价格: $%.2f\n", car.Price)

    // 修改字段
    car.Price = 23000.0
    car.Features = append(car.Features, "无线充电")

    fmt.Printf("更新后的价格: $%.2f\n", car.Price)
    fmt.Printf("功能列表: %v\n", car.Features)

    // 遍历功能列表
    fmt.Println("详细功能:")
    for i, feature := range car.Features {
        fmt.Printf("%d. %s\n", i+1, feature)
    }
}

指针访问 #

package main

import "fmt"

type Point struct {
    X, Y float64
}

func main() {
    // 创建结构体
    p1 := Point{X: 3.0, Y: 4.0}
    fmt.Printf("点1: %+v\n", p1)

    // 创建指针
    p2 := &Point{X: 1.0, Y: 2.0}
    fmt.Printf("点2: %+v\n", *p2)

    // 通过指针访问字段
    fmt.Printf("点2的X坐标: %.2f\n", p2.X) // Go 自动解引用
    fmt.Printf("点2的Y坐标: %.2f\n", (*p2).Y) // 显式解引用

    // 修改指针指向的结构体
    p2.X = 5.0
    p2.Y = 6.0
    fmt.Printf("修改后的点2: %+v\n", *p2)

    // 函数参数传递
    modifyPoint(&p1)
    fmt.Printf("函数修改后的点1: %+v\n", p1)
}

func modifyPoint(p *Point) {
    p.X *= 2
    p.Y *= 2
}

结构体的比较 #

可比较的结构体 #

package main

import "fmt"

type Coordinate struct {
    X, Y int
}

type Person struct {
    Name string
    Age  int
}

func main() {
    // 相同类型的结构体可以比较
    c1 := Coordinate{X: 1, Y: 2}
    c2 := Coordinate{X: 1, Y: 2}
    c3 := Coordinate{X: 2, Y: 3}

    fmt.Printf("c1 == c2: %t\n", c1 == c2) // true
    fmt.Printf("c1 == c3: %t\n", c1 == c3) // false

    // 结构体数组的比较
    people1 := [2]Person{
        {"Alice", 25},
        {"Bob", 30},
    }

    people2 := [2]Person{
        {"Alice", 25},
        {"Bob", 30},
    }

    fmt.Printf("people1 == people2: %t\n", people1 == people2) // true

    // 零值比较
    var p1, p2 Person
    fmt.Printf("零值结构体相等: %t\n", p1 == p2) // true
}

不可比较的结构体 #

package main

import "fmt"

type Student struct {
    Name   string
    Scores []int    // 切片不可比较
}

type Teacher struct {
    Name     string
    Subjects map[string]bool // 映射不可比较
}

func main() {
    s1 := Student{
        Name:   "张三",
        Scores: []int{85, 92, 78},
    }

    s2 := Student{
        Name:   "张三",
        Scores: []int{85, 92, 78},
    }

    // 以下代码会编译错误，因为包含切片
    // fmt.Printf("s1 == s2: %t\n", s1 == s2)

    // 可以比较单个字段
    fmt.Printf("姓名相同: %t\n", s1.Name == s2.Name)

    // 手动比较切片
    scoresEqual := compareSlices(s1.Scores, s2.Scores)
    fmt.Printf("成绩相同: %t\n", scoresEqual)
}

func compareSlices(a, b []int) bool {
    if len(a) != len(b) {
        return false
    }
    for i, v := range a {
        if v != b[i] {
            return false
        }
    }
    return true
}

匿名字段和嵌入 #

匿名字段 #

package main

import "fmt"

type User struct {
    string // 匿名字段，类型作为字段名
    int    // 匿名字段
    bool   // 匿名字段
}

type Employee struct {
    Name   string
    string // 匿名字段，通常用于嵌入
    int    // 匿名字段
}

func main() {
    // 使用匿名字段
    user := User{
        string: "Alice",
        int:    25,
        bool:   true,
    }

    fmt.Printf("用户: %+v\n", user)
    fmt.Printf("姓名: %s\n", user.string)
    fmt.Printf("年龄: %d\n", user.int)
    fmt.Printf("激活: %t\n", user.bool)

    // 更实际的例子
    emp := Employee{
        Name:   "Bob",
        string: "工程师", // 可以表示职位
        int:    5000,    // 可以表示工资
    }

    fmt.Printf("员工: %+v\n", emp)
}

结构体嵌入 #

package main

import "fmt"

type Address struct {
    Street   string
    City     string
    PostCode string
}

type Contact struct {
    Phone string
    Email string
}

type Person struct {
    Name    string
    Age     int
    Address // 嵌入结构体
    Contact // 嵌入结构体
}

func main() {
    person := Person{
        Name: "张三",
        Age:  30,
        Address: Address{
            Street:   "中山路123号",
            City:     "南京",
            PostCode: "210000",
        },
        Contact: Contact{
            Phone: "138-0000-0000",
            Email: "[email protected]",
        },
    }

    // 直接访问嵌入结构体的字段
    fmt.Printf("姓名: %s\n", person.Name)
    fmt.Printf("城市: %s\n", person.City)     // 直接访问 Address.City
    fmt.Printf("电话: %s\n", person.Phone)    // 直接访问 Contact.Phone

    // 也可以通过嵌入结构体访问
    fmt.Printf("邮编: %s\n", person.Address.PostCode)
    fmt.Printf("邮箱: %s\n", person.Contact.Email)

    // 修改嵌入字段
    person.City = "上海"
    person.Phone = "139-1111-1111"

    fmt.Printf("修改后: %+v\n", person)
}

结构体标签 #

基本标签使用 #

package main

import (
    "encoding/json"
    "fmt"
    "reflect"
)

type User struct {
    ID       int    `json:"id" xml:"id" db:"user_id"`
    Name     string `json:"name" xml:"name" db:"username"`
    Email    string `json:"email" xml:"email" db:"email_address"`
    Password string `json:"-" xml:"-" db:"password_hash"` // 忽略字段
    Age      int    `json:"age,omitempty" xml:"age,omitempty"` // 空值时忽略
}

func main() {
    user := User{
        ID:       1,
        Name:     "张三",
        Email:    "[email protected]",
        Password: "secret123",
        Age:      0, // 零值，会被 omitempty 忽略
    }

    // JSON 序列化
    jsonData, err := json.Marshal(user)
    if err != nil {
        fmt.Printf("JSON 序列化错误: %v\n", err)
        return
    }
    fmt.Printf("JSON: %s\n", jsonData)

    // 反射获取标签信息
    userType := reflect.TypeOf(user)
    for i := 0; i < userType.NumField(); i++ {
        field := userType.Field(i)
        jsonTag := field.Tag.Get("json")
        dbTag := field.Tag.Get("db")

        fmt.Printf("字段: %s, JSON标签: %s, DB标签: %s\n",
                   field.Name, jsonTag, dbTag)
    }
}

自定义标签验证 #

package main

import (
    "fmt"
    "reflect"
    "strconv"
    "strings"
)

type Product struct {
    Name     string  `validate:"required,min=2,max=50"`
    Price    float64 `validate:"required,min=0"`
    Category string  `validate:"required,oneof=electronics books clothing"`
    Stock    int     `validate:"min=0"`
}

func validateStruct(s interface{}) []string {
    var errors []string
    v := reflect.ValueOf(s)
    t := reflect.TypeOf(s)

    for i := 0; i < v.NumField(); i++ {
        field := v.Field(i)
        fieldType := t.Field(i)
        tag := fieldType.Tag.Get("validate")

        if tag == "" {
            continue
        }

        fieldName := fieldType.Name
        fieldValue := field.Interface()

        // 解析验证规则
        rules := strings.Split(tag, ",")
        for _, rule := range rules {
            if err := validateRule(fieldName, fieldValue, rule); err != "" {
                errors = append(errors, err)
            }
        }
    }

    return errors
}

func validateRule(fieldName string, value interface{}, rule string) string {
    parts := strings.Split(rule, "=")
    ruleName := parts[0]

    switch ruleName {
    case "required":
        if isZeroValue(value) {
            return fmt.Sprintf("%s 是必填字段", fieldName)
        }
    case "min":
        if len(parts) != 2 {
            return ""
        }
        minVal, _ := strconv.Atoi(parts[1])

        switch v := value.(type) {
        case string:
            if len(v) < minVal {
                return fmt.Sprintf("%s 长度不能少于 %d", fieldName, minVal)
            }
        case int:
            if v < minVal {
                return fmt.Sprintf("%s 不能小于 %d", fieldName, minVal)
            }
        case float64:
            if v < float64(minVal) {
                return fmt.Sprintf("%s 不能小于 %d", fieldName, minVal)
            }
        }
    case "max":
        if len(parts) != 2 {
            return ""
        }
        maxVal, _ := strconv.Atoi(parts[1])

        switch v := value.(type) {
        case string:
            if len(v) > maxVal {
                return fmt.Sprintf("%s 长度不能超过 %d", fieldName, maxVal)
            }
        }
    case "oneof":
        if len(parts) != 2 {
            return ""
        }
        validValues := strings.Split(parts[1], " ")
        strValue := fmt.Sprintf("%v", value)

        for _, valid := range validValues {
            if strValue == valid {
                return ""
            }
        }
        return fmt.Sprintf("%s 必须是以下值之一: %s", fieldName, parts[1])
    }

    return ""
}

func isZeroValue(value interface{}) bool {
    switch v := value.(type) {
    case string:
        return v == ""
    case int:
        return v == 0
    case float64:
        return v == 0.0
    default:
        return false
    }
}

func main() {
    // 有效的产品
    validProduct := Product{
        Name:     "iPhone 15",
        Price:    999.99,
        Category: "electronics",
        Stock:    100,
    }

    errors := validateStruct(validProduct)
    if len(errors) == 0 {
        fmt.Println("有效产品验证通过")
    } else {
        fmt.Println("验证错误:")
        for _, err := range errors {
            fmt.Printf("- %s\n", err)
        }
    }

    // 无效的产品
    invalidProduct := Product{
        Name:     "A", // 太短
        Price:    -10, // 负数
        Category: "invalid", // 无效分类
        Stock:    -5, // 负库存
    }

    errors = validateStruct(invalidProduct)
    fmt.Println("\n无效产品验证结果:")
    for _, err := range errors {
        fmt.Printf("- %s\n", err)
    }
}

结构体的内存布局 #

字段对齐 #

package main

import (
    "fmt"
    "unsafe"
)

type BadStruct struct {
    A bool   // 1 字节
    B int64  // 8 字节
    C bool   // 1 字节
    D int32  // 4 字节
    E bool   // 1 字节
}

type GoodStruct struct {
    B int64  // 8 字节
    D int32  // 4 字节
    A bool   // 1 字节
    C bool   // 1 字节
    E bool   // 1 字节
    // 编译器会添加填充
}

type OptimalStruct struct {
    B int64  // 8 字节
    D int32  // 4 字节
    A, C, E bool // 3 个 bool 连续存储
    // 1 字节填充
}

func main() {
    fmt.Printf("BadStruct 大小: %d 字节\n", unsafe.Sizeof(BadStruct{}))
    fmt.Printf("GoodStruct 大小: %d 字节\n", unsafe.Sizeof(GoodStruct{}))
    fmt.Printf("OptimalStruct 大小: %d 字节\n", unsafe.Sizeof(OptimalStruct{}))

    // 分析字段偏移
    bad := BadStruct{}
    fmt.Println("\nBadStruct 字段偏移:")
    fmt.Printf("A: %d\n", unsafe.Offsetof(bad.A))
    fmt.Printf("B: %d\n", unsafe.Offsetof(bad.B))
    fmt.Printf("C: %d\n", unsafe.Offsetof(bad.C))
    fmt.Printf("D: %d\n", unsafe.Offsetof(bad.D))
    fmt.Printf("E: %d\n", unsafe.Offsetof(bad.E))

    good := GoodStruct{}
    fmt.Println("\nGoodStruct 字段偏移:")
    fmt.Printf("B: %d\n", unsafe.Offsetof(good.B))
    fmt.Printf("D: %d\n", unsafe.Offsetof(good.D))
    fmt.Printf("A: %d\n", unsafe.Offsetof(good.A))
    fmt.Printf("C: %d\n", unsafe.Offsetof(good.C))
    fmt.Printf("E: %d\n", unsafe.Offsetof(good.E))
}

实际应用示例 #

配置管理 #

package main

import (
    "encoding/json"
    "fmt"
    "os"
)

type DatabaseConfig struct {
    Host     string `json:"host"`
    Port     int    `json:"port"`
    Username string `json:"username"`
    Password string `json:"password"`
    Database string `json:"database"`
    MaxConns int    `json:"max_connections"`
}

type ServerConfig struct {
    Host         string `json:"host"`
    Port         int    `json:"port"`
    ReadTimeout  int    `json:"read_timeout"`
    WriteTimeout int    `json:"write_timeout"`
}

type LogConfig struct {
    Level    string `json:"level"`
    FilePath string `json:"file_path"`
    MaxSize  int    `json:"max_size"`
}

type AppConfig struct {
    Database DatabaseConfig `json:"database"`
    Server   ServerConfig   `json:"server"`
    Log      LogConfig      `json:"log"`
    Debug    bool           `json:"debug"`
}

func (c *AppConfig) LoadFromFile(filename string) error {
    file, err := os.Open(filename)
    if err != nil {
        return fmt.Errorf("无法打开配置文件: %v", err)
    }
    defer file.Close()

    decoder := json.NewDecoder(file)
    return decoder.Decode(c)
}

func (c *AppConfig) SaveToFile(filename string) error {
    file, err := os.Create(filename)
    if err != nil {
        return fmt.Errorf("无法创建配置文件: %v", err)
    }
    defer file.Close()

    encoder := json.NewEncoder(file)
    encoder.SetIndent("", "  ")
    return encoder.Encode(c)
}

func (c *AppConfig) Validate() error {
    if c.Database.Host == "" {
        return fmt.Errorf("数据库主机不能为空")
    }
    if c.Database.Port <= 0 || c.Database.Port > 65535 {
        return fmt.Errorf("数据库端口无效")
    }
    if c.Server.Port <= 0 || c.Server.Port > 65535 {
        return fmt.Errorf("服务器端口无效")
    }
    return nil
}

func main() {
    // 创建默认配置
    config := AppConfig{
        Database: DatabaseConfig{
            Host:     "localhost",
            Port:     5432,
            Username: "admin",
            Password: "password",
            Database: "myapp",
            MaxConns: 10,
        },
        Server: ServerConfig{
            Host:         "0.0.0.0",
            Port:         8080,
            ReadTimeout:  30,
            WriteTimeout: 30,
        },
        Log: LogConfig{
            Level:    "info",
            FilePath: "/var/log/myapp.log",
            MaxSize:  100,
        },
        Debug: false,
    }

    // 保存配置到文件
    if err := config.SaveToFile("config.json"); err != nil {
        fmt.Printf("保存配置失败: %v\n", err)
        return
    }

    // 从文件加载配置
    var loadedConfig AppConfig
    if err := loadedConfig.LoadFromFile("config.json"); err != nil {
        fmt.Printf("加载配置失败: %v\n", err)
        return
    }

    // 验证配置
    if err := loadedConfig.Validate(); err != nil {
        fmt.Printf("配置验证失败: %v\n", err)
        return
    }

    fmt.Printf("配置加载成功: %+v\n", loadedConfig)

    // 清理临时文件
    os.Remove("config.json")
}

数据模型 #

package main

import (
    "fmt"
    "time"
)

type User struct {
    ID        int       `json:"id" db:"id"`
    Username  string    `json:"username" db:"username"`
    Email     string    `json:"email" db:"email"`
    Password  string    `json:"-" db:"password_hash"`
    CreatedAt time.Time `json:"created_at" db:"created_at"`
    UpdatedAt time.Time `json:"updated_at" db:"updated_at"`
    Profile   Profile   `json:"profile"`
}

type Profile struct {
    FirstName string `json:"first_name" db:"first_name"`
    LastName  string `json:"last_name" db:"last_name"`
    Avatar    string `json:"avatar" db:"avatar"`
    Bio       string `json:"bio" db:"bio"`
}

type Post struct {
    ID        int       `json:"id" db:"id"`
    Title     string    `json:"title" db:"title"`
    Content   string    `json:"content" db:"content"`
    AuthorID  int       `json:"author_id" db:"author_id"`
    Author    User      `json:"author"`
    Tags      []Tag     `json:"tags"`
    CreatedAt time.Time `json:"created_at" db:"created_at"`
    UpdatedAt time.Time `json:"updated_at" db:"updated_at"`
}

type Tag struct {
    ID   int    `json:"id" db:"id"`
    Name string `json:"name" db:"name"`
}

type Comment struct {
    ID        int       `json:"id" db:"id"`
    Content   string    `json:"content" db:"content"`
    PostID    int       `json:"post_id" db:"post_id"`
    AuthorID  int       `json:"author_id" db:"author_id"`
    Author    User      `json:"author"`
    CreatedAt time.Time `json:"created_at" db:"created_at"`
}

// 用户方法
func (u *User) FullName() string {
    return fmt.Sprintf("%s %s", u.Profile.FirstName, u.Profile.LastName)
}

func (u *User) IsValid() bool {
    return u.Username != "" && u.Email != ""
}

// 文章方法
func (p *Post) Summary(length int) string {
    if len(p.Content) <= length {
        return p.Content
    }
    return p.Content[:length] + "..."
}

func (p *Post) HasTag(tagName string) bool {
    for _, tag := range p.Tags {
        if tag.Name == tagName {
            return true
        }
    }
    return false
}

func main() {
    // 创建用户
    user := User{
        ID:       1,
        Username: "johndoe",
        Email:    "[email protected]",
        Password: "hashed_password",
        CreatedAt: time.Now(),
        UpdatedAt: time.Now(),
        Profile: Profile{
            FirstName: "John",
            LastName:  "Doe",
            Avatar:    "avatar.jpg",
            Bio:       "Software Developer",
        },
    }

    // 创建标签
    tags := []Tag{
        {ID: 1, Name: "Go"},
        {ID: 2, Name: "编程"},
        {ID: 3, Name: "教程"},
    }

    // 创建文章
    post := Post{
        ID:       1,
        Title:    "Go 语言结构体详解",
        Content:  "结构体是 Go 语言中非常重要的数据类型，它允许我们将相关的数据组织在一起...",
        AuthorID: user.ID,
        Author:   user,
        Tags:     tags,
        CreatedAt: time.Now(),
        UpdatedAt: time.Now(),
    }

    // 创建评论
    comment := Comment{
        ID:       1,
        Content:  "这篇文章写得很好，学到了很多！",
        PostID:   post.ID,
        AuthorID: user.ID,
        Author:   user,
        CreatedAt: time.Now(),
    }

    // 使用方法
    fmt.Printf("作者全名: %s\n", user.FullName())
    fmt.Printf("用户有效: %t\n", user.IsValid())
    fmt.Printf("文章摘要: %s\n", post.Summary(50))
    fmt.Printf("包含 Go 标签: %t\n", post.HasTag("Go"))
    fmt.Printf("包含 Java 标签: %t\n", post.HasTag("Java"))

    // 输出完整信息
    fmt.Printf("\n文章信息:\n")
    fmt.Printf("标题: %s\n", post.Title)
    fmt.Printf("作者: %s\n", post.Author.FullName())
    fmt.Printf("标签: ")
    for i, tag := range post.Tags {
        if i > 0 {
            fmt.Print(", ")
        }
        fmt.Print(tag.Name)
    }
    fmt.Printf("\n评论: %s\n", comment.Content)
}

小结 #

本节详细介绍了 Go 语言结构体的基础知识，主要内容包括：

结构体基础 #

定义语法：使用 type 和 struct 关键字定义结构体
零值：结构体的零值是所有字段都为对应类型的零值
初始化：支持字面量初始化、new 函数和指针初始化
字段访问：使用点操作符访问字段，支持指针自动解引用

高级特性 #

匿名字段：类型作为字段名的特殊字段
结构体嵌入：实现类似继承的功能
结构体标签：为字段添加元数据，支持序列化和验证
内存布局：理解字段对齐和内存优化

实际应用 #

配置管理：使用结构体组织配置信息
数据模型：构建业务领域模型
API 数据：定义请求和响应结构
数据库映射：ORM 框架的基础

最佳实践 #

合理组织字段顺序以优化内存使用
使用结构体标签提供元数据
通过嵌入实现代码复用
为结构体定义有意义的方法

结构体是 Go 语言面向对象编程的基础，掌握其使用方法对于编写高质量的 Go 代码至关重要。

练习题：

定义一个学生管理系统的数据结构，包含学生、课程、成绩等实体
实现一个简单的图书管理系统，支持图书的增删改查
创建一个配置管理器，支持从 JSON 文件加载和保存配置
设计一个电商系统的商品数据结构，包含商品分类、属性等
实现一个简单的用户权限系统，使用结构体嵌入实现角色继承