Go语言中，也和C或者其他语言一样，我们可以声明新的类型，作为其它类型的属性或字段的容器。
结构体定义
type identifier struct {
field1 type1
field2 type2
...
}
在结构体内部定义它们的成员变量和类型，只是类型要放到后面，并且变量之间不用逗号。
type Student struct {
name string
age int
}
如果成员变量的类型相同的话，可以把它们写到同一行，比如：
type T struct {
a, b int
}
结构体里的字段都有名字，像 field1、field2 等，如果字段在代码中从来也不会被用到，那么可以命名它为 _。
初始化
初始化方式1：先声明变量，再给变量属性赋值
type person struct {
name string
age int
}
var P person // P是person类型的变量
P.name = "ABC" // 赋值
P.age = 25 // 赋值
fmt.Printf("The person's name is %s", P.name) // 访问P的name属性
初始化方式2：按照顺序提供初始值
P := person{"ABC", 25}
初始化方式3：通过field.value的方式，这样可以任意顺序
P := person{age:25, name:"ABC"}
初始化方式4：通过new函数分配一个指针，此处P的类型为*person
P := new(person)
综合示例：
// 声明类型
type person struct {
name string
age int
}
// 比较两个人的年龄，返回年龄大的那个人，并且返回年龄差
func Older(p1, p2 person) (person, int) {
if p1.age > p2.age {
return p1, p1.age - p2.age
}
return p2, p2.age - p1.age
}
func main() {
var tom person
tom.name, tom.age = "ABC", 24 // 初始化方式1
bob := person{age:24, name:"ABC"} // 初始化方式3
Paul := person{"Paul", 24} // 初始化方式2
tb_Older,tb_diff:=Older(tom, bob)
tp_Older,tp_diff:=Older(tom, Paul)
bp_Older,bp_diff:=Older(bob, Paul)
fmt.Printf("Of %s and %s, %s is older by %d years\n", tom.name, bob.name, tb_Older.name, tb_diff)
}
打印输出
在Go语言里可以直接使用 fmt.Println 打印一个结构体，默认输出可以很好的显示它的内容，类似使用 %v 选项。
结构体new函数
type T struct {a, b int}
使用 t := new(T) 给该结构体变量分配内存，它返回指向已分配内存的指针。变量 t 是一个指向 T 的指针，此时结构体字段的值是它们所属类型的零值。
声明 var t T 也会给 t 分配内存，并零值化内存，但是这个时候 t是类型T。
在这两种方式中，t 通常被称做类型T的一个实例（instance）或对象（Object）。
var t *T = new(T) 等价于 t := new(T)。
type struct1 struct {
i1 int
f1 float32
str string
}
func main() {
ms := new(struct1)
ms.i1 = 10
ms.f1 = 15.5
ms.str= "Chris"
fmt.Printf("The int is: %d\n", ms.i1) // 10
fmt.Printf("The float is: %f\n", ms.f1) // 15.500000
fmt.Printf("The string is: %s\n", ms.str) // Chirs
fmt.Println(ms) // &{10 15.5 Chris}
}
使用 _ 补位
type Circle struct {
_ float64
y float64
r float64
}
直接定义匿名结构变量
u := struct {
name string
age byte
}
匿名字段
以上定义的时候是字段名与其类型一一对应，Go支持只提供类型，而不写字段名的方式，也就是匿名字段，也成为嵌入字段。
当匿名字段是一个struct的时候，那么这个struct所拥有的全部字段都被隐式地引入了当前定义的这个struct。
type Human struct {
name string
age int
phone string // Human类型拥有的字段phone
}
type Student struct {
Human // 匿名字段，那么默认Student就包含了Human的所有字段
speciality string
int // 内置类型int作为匿名字段
string // 内置类型string作为匿名字段
phone string // Student类型拥有的字段phone
}
func main() {
mark := Student{Human{"ABC", 24, "10086"}, "Computer Science",82,"GG","10010"}
// 访问相应的字段
fmt.Println("His name is ", mark.name)
fmt.Println("His age is ", mark.age)
fmt.Println("His speciality is ", mark.speciality)
// 修改对应的备注信息
mark.speciality = "AI"
fmt.Println("Mark changed his speciality")
fmt.Println("His speciality is ", mark.speciality)
// 修改他的年龄信息
fmt.Println("Mark become old")
mark.age = 46
fmt.Println("His age is", mark.age)
// 访问匿名字段
fmt.Println("int is", mark.int) // 82
fmt.Println("string is", mark.string) // GG
// 访问字段phone
fmt.Println("Human's phone is:", Bob.phone) // 10010
fmt.Println("Student's phone is:", Bob.Human.phone) // 10086
}
human里面有一个字段叫做phone，而student也有一个字段叫做phone，那么最外层的优先访问，也就是当你通过student.phone访问的时候，是访问student里面的字段，而不是human里面的字段。
空结构
var a struct{}
var b [100]{}
println(unsafe.Sizeof(a), unsafe.Sizeof(b)) // 0 0
字段标签
字段标签并不是注释，用来对字段进行描述的元数据。
import (
"fmt"
"reflect"
)
type User struct {
Name string "昵称"
Sex byte "性别"
}
func main() {
u := User{"Mike", 1}
v := reflect.ValueOf(u)
t := v.Type()
for i, n := 0, t.NumField(); i < n; i++ {
fmt.Printf("%s: %v\n", t.Field(i).Tag, v.Field(i))
}
}
输出：
昵称：Mike
性别：1
type InformationWithLabel struct{
Name string `json:"name"`
Age int `json:"age"`
}
这种带标签的结构体的定义，在转换为json格式的数据的时候会自动将对应的字段转换为标签中的字段：
比如：Name 转换为 name 字段。
标签字段不能在编程中实际使用。
比如：可以这样:InformationWithLabel.Name
不可以这样：InformationWithLabel.name
