Go 语言结构体
基本概念
结构体（Struct）是一种自定义数据类型，由一系列相同或不同类型的数据组成，以实现较复杂的数据结构。Go 语言的结构体是值类型。
定义和初始化
结构体是自定义类型，因此在声明和初始化结构体变量前，需要显式定义结构体类型。这也是静态语言特色，所有数据在编译时都必须有明确类型。
定义结构体
结构体类型通过关键字 struct 来定义，内部可以包含多个字段（Field），每个字段都有独自类型和名称：
type StructName struct {
Field1 FieldType1
Field2 FieldType2
// 更多字段...
}StructName：结构体名称，虽然标识符首字母能决定是否导出，但通常以大写字母开头。Field1：字段名称，通常也以大写字母开头，可选。字段名在结构体中必须唯一，可以使用空标识符。FieldType1：字段类型，可以是任何有效类型，包括基本类型、函数、接口或者其他结构体类型。
此外，和定义常量组类似，相同类型字段可以定义在一起：
package main
type Person struct {
Name, City string // 相同类型定义在一起
Age int
}
func main() {
}初始化结构体
结构体变量称为结构体的实例或对象，访问实例字段用点号 . 作为操作符。声明并初始化结构体变量常用 3 种方式：
package main
import "fmt"
type Person struct {
Name string
Age int
}
func main() {
// 声明后再赋值
var p1 Person // 自动初始化为类型零值
p1.Name = "Unknown" // 单独赋值
// 使用字面量初始化
p2 := Person{Name: "bob"} // 指定字段名赋值，允许部分赋值，不依赖赋值顺序
p3 := Person{"Bob", 11} // 省略字段名赋值，必须全部字段赋值，不能和键值对赋值混用
// 使用 new 函数初始化，获得指针
p4 := new(Person) // 等同于 p4 := &Person{}
p4.Name, p4.Age = "Alice", 10 // 并行赋值
// 各种打印输出结构体方式
fmt.Println(p1.Name, p1.Age) // 输出：Unknown 0
fmt.Println(p2) // 输出：{bob 0}
fmt.Printf("%+v\n", p3) // 输出：{Name:Bob Age:11}
fmt.Printf("%#v", p4) // 输出：&main.Person{Name:"Alice", Age:10}
}结构体有时也通过工厂函数来初始化，在工厂函数中能封装错误检查或附加设置：
package main
import "fmt"
type Person struct {
Name string
Age uint
}
func NewPerson(name string, age uint) *Person {
// 可以对输入参数做些额外检查
if age > 120 {
panic("请输入正确参数")
}
return &Person{Name: name, Age: age}
}
func main() {
p := NewPerson("Alice", 30)
fmt.Println(p)
}嵌套结构体
结构体可以嵌套其他结构体和自定义类型，以创建更复杂的数据结构：
package main
import "fmt"
// BasicColor 结构体表示颜色 RGB 值
type BasicColor struct {
Red, Green, Blue int
}
// AdvancedColor 结构体内嵌 BasicColor，并添加透明度 Alpha
type AdvancedColor struct {
BasicColor BasicColor
Alpha float32
}
func main() {
color := AdvancedColor{}
color.BasicColor.Red = 255 // 通过层级访问嵌套结构体字段
// 可以单独对内嵌结构体实例化，再引用赋值
bc := BasicColor{Green: 255}
color = AdvancedColor{
BasicColor: bc, // 更美观更结构化
Alpha: 0.89, // 结尾逗号不能省略
}
fmt.Printf("%+v\n", color) // 输出：{BasicColor:{Red:0 Green:255 Blue:0} Alpha:0.89}
}匿名结构体
匿名结构体没有类型名称，在定义的同时进行初始化，只能一次性使用：
package main
import "fmt"
func main() {
// 直接使用匿名结构体定义变量
admin := struct {
Id int
Name string
}{1, "admin"}
fmt.Printf("%+v\n", admin) // 输出：{Id:1 Name:admin}
fmt.Printf("%T\n", admin) // 输出：struct { Id int; Name string }
// 在 new 函数中使用匿名结构体
user := new(struct {
Id int
Name string
})
fmt.Printf("%+v\n", user) // 输出：&{Id:0 Name:}
}当结构体在极小作用域内使用时，可以使用匿名结构体来避免全局命名空间污染。
匿名字段
结构体可包含多个匿名字段，匿名字段只有类型没有命名，匿名字段名隐式等于类型名（导出也由类型名决定），所以每种数据类型只能有一个匿名字段，否则会命名冲突。匿名字段常用于嵌入其他结构体或接口，从而实现类似于继承的功能：
package main
import "fmt"
type Person struct {
Name string
Age int
}
type Employee struct {
Person // 匿名字段
Salary int
}
// 三种赋值方式
func main() {
// 命名字段赋值
e := Employee{
Salary: 5000,
Person: Person{
Name: "John",
Age: 30,
},
}
// 赋值时忽略字段名，要注意顺序
e = Employee{Person{"Cale", 30}, 6000}
// 直接访问修改匿名字段属性
e.Age = 32
e.Person.Age = 31
fmt.Println(e.Name, e.Age, e.Salary)
}使用匿名字段可以简化调用名称。发生字段名冲突时，必须显式指定嵌入类型名来解决歧义：
package main
import "fmt"
type Person struct {
Name string // Person 中 Name 字段表示真名
}
type Employee struct {
Person // 内嵌 Person 结构体，匿名字段
Name string // Employee 中 Name 字段表示职位
}
func main() {
// 忽略字段名快速初始化赋值
e := Employee{
Person{"Alice"},
"CEO",
}
// 分别访问两个 Name 字段值
fmt.Println(e.Person.Name, e.Name) // 输出：Alice CEO
}结构体应用
结构体一般会绑定方法来使用，这里列举一些方法以外的应用。
比较和赋值
相同类型结构体之间可以直接比较和赋值：
package main
import "fmt"
type Person struct {
Name string
Age int
}
func main() {
// 初始化两个 Person 类型实例
p1 := Person{Name: "Alice", Age: 20}
p2 := Person{}
// 结构体相同可以直接赋值
p2 = p1
// 比较结构体实例内容
fmt.Println(p1 == p2) // 输出：true
}注意，如果结构体类型不同，操作会报错。包括有完全相同字段但命名不同的结构体类型之间，也无法进行比较赋值。匿名结构体则可以忽略类型名，直接比较字段，类似无类型常量：
package main
import "fmt"
type Person struct {
Name string
Age int
}
type Man struct {
Name string
Age int
}
func main() {
// 结构体字段和内容相同，只有类型名不同
p1 := Person{Name: "Alice", Age: 20}
p2 := Man{"Alice", 20}
//fmt.Println(p1 == p2) // 无法直接比较和赋值，类型不同
// 同样数据结构匿名结构体
p3 := struct {
Name string
Age int
}{"Alice", 20}
// 可以比较
fmt.Println(p2 == p3 || p1 == p3) // 输出：true
// 也可以互相赋值
p1, p3 = p3, p2
}结构体转换
上面提到，如果两个不同名字结构体类型具有相同的字段名、字段类型和字段顺序，依然是不同类型，不能直接互相赋值和比较。但它们的值可以互相转换，类似不同长度整型间转换一样直接：
package main
import "fmt"
type Person struct{ Name string }
type Man struct{ Name string }
func main() {
// 结构体转换，结构体类型名加要转换的类型
p1 := Person{Name: "Alice"}
p2 := Man(p1)
fmt.Println(p1, p2)
fmt.Printf("%T %T", p1, p2) // 输出不同类型：main.Person main.Man
}传递结构体
由于结构体成员可以是引用类型数据，因此传递结构体时并非传递数据完整副本。值类型数据会创建副本，引用类型数据则保持引用特性，指向原始数据：
package main
import "fmt"
type Person struct {
ID int
Names []string
}
func main() {
// 结构体中包含值类型和引用类型
p1 := Person{Names: []string{"Alice"}}
fmt.Println("原始数据：", p1)
p2 := p1 // 赋值时发生值传递
p1.ID = 1 // 修改值类型字段
p1.Names[0] = "Malice" // 修改引用类型字段
fmt.Println("原始数据修改后：", p1) // 两个字段都有修改
fmt.Println("副本数据跟着变：", p2) // 值类型字段不受影响，引用类型字段跟着修改
// 结构体指针类型
p3 := &p1
p3.ID = 2 // 修改指针类型字段
fmt.Println("指针副本数据：", p3)
}因此，在函数中需要修改带引用类型的结构体时，最好手动创建结构体完全副本，在副本上修改再返回，避免函数副作用。
结构体标签
结构体类型还能为结构体的字段添加元信息标签（tag），标签用于为数据交换格式（json、xml、yaml）提供序列化、反序列化、验证等信息。标签内容紧接字段定义后用反引号「`」括起来：
package main
import (
"fmt"
"reflect"
)
type Person struct {
Name string `json:"name,omitempty"`
Age int `json:"age"`
}
func main() {
bob := Person{"bob", 11}
// 通过 Field 来索引结构体字段，获取 Tag 属性。输出：json:"name,omitempty"
fmt.Println(reflect.TypeOf(bob).Field(0).Tag)
}上面 Name 字段标签指定转为 JSON 格式时，使用 name 作为该字段的键名，并且值为类型零值时忽略字段。
递归结构体
结构体可以在字段定义中引用自身（指针），以表示更复杂的层次或树状数据结构，如单向链表结构：
package main
import "fmt"
type ListNode struct {
Value int // 存放有效数据
Next *ListNode // 指针指向后继节点
}
// 函数递归搜索特定值
func search(head *ListNode, value int) *ListNode {
if head == nil {
return nil
}
if head.Value == value {
return head
}
return search(head.Next, value)
}
func main() {
// 创建链表的头节点
head := &ListNode{Value: 1}
// 添加更多节点
second := &ListNode{Value: 2}
third := &ListNode{Value: 3}
head.Next = second
second.Next = third
// 搜索链表
fmt.Println(search(head, 0))
fmt.Println(search(head, 2))
}