go 结构体

go 结构体

结构体是用户定义的类型，表示若干个字段（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    
}