结构体是用户定义的类型，表示若干个字段（Field）的集合。有时应该把数据整合在一起，而不是让这些数据没有联系。这种情况下可以使用结构体(如果学过python，java的同学，可以把结构体当作类来看)
例如一个人有姓名，年龄，性别三个属性，把这个属性放在结构体Person中，代码如下:
// 定义一个结构体
type Person struct {
name string
age int
sex string
hobby []string
}
我们定义了一个结构体之后，也需要初始化结构,下面介绍三种结构体的初始化方案，
// 初始化结构体
var person Person
fmt.Println(person) // { 0 []} 结构体是值类型数据，因此初始化后会有默认零值
hobby := make([]string, 4, 4)
var person = Person{"lxx", 19, "男", hobby}
fmt.Println(person) // {lxx 19 男 [ ]} 按位置传参,需要符合顺序，不能少传
var person = Person{hobby:hobby, name: "lxx", age: 19}
fmt.Println(person) // {lxx 19 [ ]} 关键字传参，不用符合顺序,可以少传
补充: 结构体的零值是每个字段的零值
数字：0
字符串： ""
布尔： false
数组: [元素的零值，]
结构体： 字段的零值
定义完之后就是怎么使用，和python一样，通过 点号操作符 . 用于访问结构体的字段和方法
hobby := make([]string, 4, 4)
var person = Person{"lxx", 19, "男", hobby}
fmt.Println(person.age) // 打印 person 的 age 属性
person.name = "yxx" // 修改 name 属性为 yxx
person.hobby[0] = "篮球" // 切片已经初始话了，如果没有初始化就是 nil
fmt.Println(person) // {yxx 19 男 [篮球 ]}
匿名结构体指定义在函数内部,只能使用一次的结构体，匿名结构体不需要 type和名字
p1 := struct {
name string
age int
}{} // 允许不赋值
p := struct {
name string
age int
}{"lxx", 18}
fmt.Println(p.name) // lxx
fmt.Println(p) // {lxx 18}
在结构体中不只有匿名结构体，结构体中的字段也是可以匿名的,但是匿名字段每一个类型只允许存在一个，相当于用类型当作属性名,并且匿名字段只支持部分类型数据
func main() {
animal := Animal{"yxx",16, 17, "lxx"， true}
animal1 := Animal{string:"zxx",int:19} // 按关键字，类型名就是字段名
fmt.Println(animal) // {yxx 16 17 lxx}
fmt.Println(animal1)
}
// 匿名字段结构体
type Animal struct {
string // 字段没有名字，类型名就是字段名
int
age int
name string
bool
//[]string // 报错
//map[int]string // 报错
//[3]string // 报错
}
结构体的字段允许是一个结构体。这样的结构体称为嵌套结构体。(这里就开始和面向对象的继承类似了)
func main() {
hobby := make([]string, 4, 4)
person := Person{"男", hobby, Animal{"lxx", 15}} // 位置传参
person1 := Person{sex: "男", hobby: hobby, animal: Animal{name: "zxx", age: 12}} // 关键字传参
fmt.Println(person) // {男 [ ] {lxx 15}}
fmt.Println(person1) // {男 [ ] {zxx 12}}
fmt.Println(person.animal.name) // 取出person的名字 lxx
fmt.Println(person.sex) // 取出person的性别 男
}
// 匿名字段结构体
type Animal struct {
name string
age int
}
// 定义一个结构体
type Person struct {
sex string
hobby []string
animal Animal // 相当于 Person 继承 Animal 类
}
并且结构体嵌套还可以嵌套匿名结构体,但是嵌套匿名结构体具有限制较多
func main() {
//Tduck := Duck{"唐老鸭",18,{"母鸭子",4}} // 报错,不支持位置传参给内部匿名结构体
//Tduck := Duck{name: "唐老鸭",age:18,wife:{"母鸭子",4}} // 报错,也不支持关键字传参
var Tduck = Duck{name: "唐老鸭",age:8} // 只能先通过关键字传参,定义出外层结构体熟悉
Tduck.wife.name = "母鸭子" // 通过 . 字段名的方式给内层匿名结构体赋值
Tduck.wife.age = 13
fmt.Println(Tduck)
}
// 嵌套匿名结构体
type Duck struct {
name string
age int
wife struct{
name string
age int
}
}
在前文中，结构体嵌套中使用内层结构体(或者说父类)的属性,需要 .结构体.字段的方式,不能像python面向对象中那样，对象可以直接使用父类的属性那样方便,那么有没有方法实现呢？答案是肯定的, go 中可以使用结构体嵌套+匿名字段的方式实现字段提升,来实现同样的效果
func main() {
hobby := make([]string, 4, 4)
person := Person{"zxx","男", hobby, Animal{"lxx", 15}} // 位置传参
// 优先用自己的，自己没有，用内存结构体(父类)的
fmt.Println(person.name) // zxx 字段重复就不能提升
fmt.Println(person.Animal.name) // lxx 本来是animal的字段，被提升到了person身上
fmt.Println(person.age) // 15 字段提升
fmt.Println(person.Animal.age) //15
fmt.Println(person) // {zxx 男 [ ] {lxx 15}}
}
type Animal struct {
name string
age int
}
// 定义一个结构体
type Person struct {
name string
sex string
hobby []string
Animal // 字段提升
}
// 在子类对象中使用父类的属性 super().属性名----》super()就是咱们这个案例的Animal
如果结构体名称以大写字母开头，则它是其他包可以访问的导出类型（Exported Type）。同样，如果结构体里的字段首字母大写，它也能被其他包访问到。
type Dog struct { // 结构体名首字母大写,能够导出
Name string // 字段名首字母大写能导出
age int // 字段名首字母小写无法导出
}
type tom struct { // 结构体名首字母小写无法导出
Name string // 受结构体影响,无法导出
}
结构体字段 首字母小写 虽然无法导出,外部包中无法直接赋值与修改(等同于python面向对象中的隐藏字段)，但是也是可以通过方法来实现对该字段的修改，详情请看下文 go 方法 。 架构体+方法 = 类的概率
结构体能否比较,取决于结构体内部字段,如果字段都是可比较的,那结构体也可以比较，如果有不可比较的字段，结构体就不可以比较。
func main() {
dog, dog1 := Dog{"公狗", 4}, Dog{"母狗", 3}
fmt.Println(dog == dog1) // 值类型，可以 == 比较
a1, a2 := Animal{"a1", 3, nil}, Animal{"a2", 2, nil}
// fmt.Println(a1 == a2) // 报错 引用类型只能 == nil ,因此不能比较
}
type Animal struct {
name string
age int
hobby []string // 切片类型不能比较
}
type Dog struct {
Name string
age int
}