golang-struct结构体

struct结构体

概述

Go 语言中数组可以存储同一类型的数据，但在结构体中我们可以为不同项定义不同的数据类型。

结构体是 Golang 中一种复合类型，它是由一组具有相同或不同类型的数据字段组成的数据结构。

结构体是一种用户自定义类型，它可以被用来封装多个字段，从而实现数据的组合和抽象化。

在 Golang 中，结构体是一种非常灵活和扩展性强的类型，它支持嵌套、组合、方法等高级特性。

类比

Golang的结构体和其他高级语言中的类相似，

1.结构体字段就是类的变量或属性。
2.结构体方法就是类的方法。
3.结构体的嵌套就是类的继承。
4.结构体的组合可以实现类的多态。

结构体的概念和定义

基本语法

结构体定义需要使用 type 和 struct 语句。

struct 语句定义一个新的数据类型，结构体中有一个或多个成员。

type 语句设定了结构体的名称。结构体的格式如下：

//语法结构
type struct_variable_type struct {member definitionmember definition...member definition
}//中文
type 结构体类型名 struct{成员1  成员类型成员2  成员类型成员3  成员类型...
}

举例

type Person struct{name stringage int64
}

注意

type表明结构体本质上就是一个类型，类型名为Person。

结构体字段

结构体的字段可以是任意类型，甚至是结构体本身，也可以是函数或者接口。

如果一个字段在代码中从来不会被用到，那可以把它命名为_，即空标识符。

大小写问题

结构体中的字段通过首字母大小写来控制私有或公有。

私有属性或方法只能在本包内访问。
公有属性或方法可以跨包访问。

json标签映射不能访问小写开头的字段是因为标签映射需要借助reflect包，属于跨包访问。

字段标记举例

type Person struct {Name  string `json:"name"`Age     int   `json:"age"`Email string `json:"email"`
}

这些标记信息通过反射接口可见，并参与结构体的类型标识，但在其他情况下被忽略。

结构体实例化

字面量初始化

字面量初始化时实例的声明和初始化同时进行。

基本语法

var 变量名 结构体类型 = 结构体类型{字段1:值,字段2:值,
}//简易初始化
var 变量名 = 结构体类型{字段1:值,字段2:值,
}//极简初始化
变量名 := 结构体类型{字段1:值,字段2:值,
}

举例

package struct_knowledgeimport "fmt"func CreateStruct(){type Person struct{name string age int64}var person = Person{name:"张三",}fmt.Printf("person实例的值为%#v\n",person)
}

结果

person实例的值为struct_knowledge.Person{name:"张三", age:0}

小结

1.实例的最后一定要用,结尾

var person = Person{//实例的最后一定要用,结尾name:"张三",
}

2.声明却没赋值的属性会采用零值

var person = Person{//实例的最后一定要用,结尾name:"张三",//age没有赋值
}//结果:
person实例的值为struct_knowledge.Person{name:"张三", //采用零值age:0,
}

赋值实例化

访问结构体成员

如果要访问结构体成员(属性和方法)，需要使用点号.操作符，格式为：

结构体实例.成员名

注意是结构体实例

举例

package struct_knowledgeimport "fmt"func CreateStruct(){type Person struct{name string age int64}var person = Person{name:"张三",}fmt.Printf("person实例的值为%#v\n",person)//访问成员fmt.Printf("person的name值为%#v\n",person.name)
}

结果

person实例的值为struct_knowledge.Person{name:"张三", age:0}
person的name值为"张三"

注意

结构体实例可以访问成员属性和成员变量，结构体类型名是不行的。(结构体类型名就是一个类型)

赋值初始化

基本语法

var 实例名 结构体类型
实例.属性 = 值
实例.属性2 = 值

举例

package struct_knowledgeimport "fmt"func CreateStruct2(){type Person struct{name string age int64}var person Personfmt.Printf("未赋值前，结构体实例的值为%#v\n",person)person.name = "张三"person.age = 19fmt.Printf("赋值后，结构体实例的值为%#v\n",person)
}

结果

未赋值前，结构体实例的值为struct_knowledge.Person{name:"", age:0}
赋值后，结构体实例的值为struct_knowledge.Person{name:"张三", age:19}

小结

1.结构体实例未赋值时，所有字段采用零值。

顺序初始化

我们也可以不写属性名赋值，但是这种必须要保证赋值顺序和结构体声明顺序一致。

顺序初始化时，实例的声明和赋值同时进行，且赋值要与结构体字段一一对应。

package struct_knowledge
import "fmt"
func CreateStruct3(){type Person struct{name string_ boolage int64}var person =  Person{"张三",true,19}fmt.Printf("赋值后，结构体实例的值为%#v\n",person)
}

结果

赋值后，结构体实例的值为struct_knowledge.Person{name:"张三", _:false, age:19}

注意事项

1.结构体中即使是`_`这种表示空标识的字段，在顺序初始化时也得赋值。
2.赋值时值的个数要与字段个数相同，不能多也不能少。

阶段总结

字面量初始化、赋值初始化都可以看作关键字赋值，无需考虑顺序，没有赋值的采用零值。

顺序初始化则是位置赋值，需要与结构体的字段一一对应，赋值个数即不能多，也不能少。

new函数

基本语法

new 函数是 Golang 中的一个内置函数，它用于创建一个指向新分配的类型为T的零值的指针。

在使用 new 函数时，我们需要传递一个类型参数，该参数表示要分配内存的类型。

基本语法

var 结构体实例 = new(结构体类型)

举例

package struct_knowledgeimport "fmt"func CreateStructByNew() {type Person struct{name stringage int}//new函数实例化person := new(Person)fmt.Printf("person的类型为%T\n",person)person.name = "张三"person.age = 19fmt.Printf("赋值后,结构体实例person的值为%#v\n",person)//普通实例var person1 Personfmt.Printf("person的类型为%T\n",person1) }

结果

person的类型为*struct_knowledge.Person
赋值后,结构体实例person的值为&struct_knowledge.Person{name:"张三", age:19}
person的类型为struct_knowledge.Person

小结

new函数得到的实例是结构体指针类型，但是由于golang的结构体和数组二者的引用类型赋值时不需要使用*指针类型取值，所以很容易产生混淆。

new的等价

new函数其实进行了两步操作

1.声明了一个指针变量
2.分配内存

我们也可以自行声明指针变量，然后用new分配内存。

声明指针变量

func CreateStruct7(){type Person struct{name stringage int}/*只声明了变量，没有分配内存，值为nil*/var person1 *Personfmt.Printf("未分配内存前,person1的值为%#v\n",person1)//未分配内存前为nil，不能操作//panic: runtime error: invalid memory address or nil pointer dereference// person1.age = 19
}

结果

未分配内存前,person1的值为(*struct_knowledge.Person)(nil)

此时我们不能赋值，就和空切片、空map一样，我们还需要分配内存。给指针类型分配内存就需要使用

//得到一个该类型的指针，并且分配了空间
new(类型)

分配空间后，将采用结构体字段的零值。

分配空间举例

package struct_knowledgeimport "fmt"func CreateStruct7(){type Person struct{name stringage int}/*只声明了变量，没有分配内存，值为nil*/var person1 *Personfmt.Printf("未分配内存前,person1的值为%#v\n",person1)//panic: runtime error: invalid memory address or nil pointer dereference// person1.age = 19//分配空间person1 = new(Person)fmt.Printf("分配内存后,未赋值前,person1的值为%#v\n",person1)person1.name = "张三"fmt.Printf("分配内存并且赋值后,person1的值为%#v\n",person1)
}

结果

未分配内存前,person1的值为(*struct_knowledge.Person)(nil)
分配内存后,未赋值前,person1的值为&struct_knowledge.Person{name:"", age:0}
分配内存并且赋值后,person1的值为&struct_knowledge.Person{name:"张三", age:0}

new的字面量赋值

易混淆误区

我们声明了一个指针类型的结构体，我们可以给他直接赋值，例如

type Person struct{name stringage int
}
var person = new(Person)
//直接赋值
person.name = "张三"

实际上这是因为golang对结构体和数组做了处理，再给结构体和数组的指针类型直接赋值时不需要使用*指针类型取内容。

var price = new(int)
//price是*int类型，在修改时为
*price = 15var lisa = new(Person)
//lisa的类型实际上为 *Person
/*常规操作*lisa.name = "张三"但是golang决定这样可读性太差就去掉了前面的*,反而增加了我们理解的难度
*/
lisa.name = "张三"

指针类型赋值

由于new函数得到的是指针类型，所以字面量赋值时就需要。

type Person struct{name stringage int
}
var person = new(Person)//需要&取地址获得指针类型
person = &Person{name:"张三",age:19
}

小结

由于结构体是值类型，所以我们在使用时要严格区分传递的是否是指针，不要囫囵吞枣。

结构体字段

golang的结构体字段很复杂，值得单独讲解。

基本形式

基本语法

字段名和字段类型

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

结构体的首字母小写，则该结构体类型只能在本包访问，反之可以跨包访问。

结构体字段的首字母小写，则该结构体字段只能在本包访问，反之可以跨包访问。

举例

type Person struct{//该字段可以跨包访问Name string//该字段不能跨包访问age int
}

跨包访问

package 包1//在包1中通过包2访问就叫跨包访问
包2.变量

同类型省略形式

基本语法

type 结构体类型 struct{字段1 类型A字段2,字段3 类型B字段4 类型C
}

等价于

type 结构体类型 struct{字段1 类型A字段2 类型B字段3 类型B字段4 类型C
}

举例

package struct_knowledgeimport "fmt"func CreateStruct4(){//同类型字段简写type Struct1 struct{IsOk boolage,price intname string}var Struct1Item = Struct1{true,20,25,"张三"}fmt.Printf("赋值后，结构体实例的值为%#v\n",Struct1Item)
}

结果

赋值后，结构体实例的值为struct_knowledge.Struct1{IsOk:true, age:20, price:25, name:"张三"}

省略字段名

基本语法

这种省略字段名实际上就是拿类型作为字段名。

类型名虽然是关键字，但是在结构体中允许关键字当字段名。

这是为结构体嵌套做铺垫。

因为嵌套结构体就是将其他结构体类型直接写到该结构体中。

type 结构体类型 struct{字段1 类型A类型B字段1 类型C
}

等价于

type 结构体类型 struct{字段1 类型A字段B 类型B字段1 类型C
}

举例

package struct_knowledgeimport "fmt"func CreateStruct5(){//省略字段名type Struct2 struct{name stringstringboolage int}//相当于/*type Struct2 struct{name stringstring stringbool  boolage int}*/var Struct2Item Struct2Struct2Item.name = "张三"Struct2Item.bool = truefmt.Printf("赋值后，结构体实例的值为%#v\n",Struct2Item)
}

结果

赋值后，结构体实例的值为struct_knowledge.Struct2{name:"张三", string:"", bool:true, age:0}

同名字段

在同一个结构体中声明同名字段，会报错，例如

//报错:name redeclared
type Struct1 struct{name stringname string
}

注意

由于golang严格区分大小写，所以首字母大小写不同或者个别字母大小写不同属于不同字段，例如

//正确，属于不同字段
type Struct1 struct{name stringName string
}

字段冲突

之所以会考虑到这个问题，是因为后续结构体嵌套会遇到同名字段问题。

结构体指针

常见方法

常见的获取结构体指针的方式如下:

package struct_knowledgeimport "fmt"
//获得指针类型结构体实例的方式
func CreateStruct8(){type Person struct{name stringage int}/*方式1：声明指针类型变量，然后用new分配内存*/var person1 *Personperson1 = new(Person)fmt.Printf("分配内存后,未赋值前,person1的值为%#v\n",person1)/*方式2:声明指针类型变量，然后字面量赋值分配内存*/var person2 *Personperson2 = &Person{}fmt.Printf("分配内存后,未赋值前,person2的值为%#v\n",person2)/*方式3:直接用new函数声明指针类型并分配内存*/var person3 = new(Person)fmt.Printf("分配内存后,未赋值前,person3的值为%#v\n",person3)/*方式4:直接用字面量取地址*/var person4 = &Person{}fmt.Printf("分配内存后,未赋值前,person4的值为%#v\n",person4)
}

结果

分配内存后,未赋值前,person1的值为&struct_knowledge.Person{name:"", age:0}
分配内存后,未赋值前,person2的值为&struct_knowledge.Person{name:"", age:0}
分配内存后,未赋值前,person3的值为&struct_knowledge.Person{name:"", age:0}
分配内存后,未赋值前,person4的值为&struct_knowledge.Person{name:"", age:0}

有个方法可以分辨操作的是否是指针，就是打印时前面是否带&

构造函数法

所谓构造函数法，就是自定义一个函数，返回结构体指针类型，该方法的命名规范New+结构体类型名，例如

 func NewPerson(name string, age int) *Person {return &Person{Name: name, Age: age}}p := NewPerson("Tom", 25)

实际上就是字面量赋值指针类型。

结构体传参

结构体实例为值类型

由于结构体是值类型，所以直接传递结构体实例时，在函数内部操作该实例的拷贝对外部原实例没影响。

package struct_knowledgeimport "fmt"//注意需要在包外操作的字段一定要首字母大写
//私有字段无法跨包访问，会提示undefined
type Student struct{Name stringAge int
}//结构体是值类型
func StructByVal(st Student){st.Age = 20fmt.Printf("函数内该结构体实例的值为%#v\n",st)
}

调用

package mainimport ("fmt""go_learn/struct_knowledge"
)//这是入口文件
func main(){//验证结构体是值类型var myStudent struct_knowledge.StudentmyStudent.Name = "张三"struct_knowledge.StructByVal(myStudent)fmt.Printf("函数外该结构体实例的值为%#v\n",myStudent)
}

结果

函数内该结构体实例的值为struct_knowledge.Student{Name:"张三", Age:20}
函数外该结构体实例的值为struct_knowledge.Student{Name:"张三", Age:0}

由于结构体是值类型，所以函数内的操作无法影响到外面的原始实例。

这也解释了为什么前后端交互传递的都是结构体实例指针，因为需要得到前端传递的值。

使用指针类型传参

举例

package struct_knowledgeimport "fmt"type Student struct{Name stringAge int
}//指针类型传递送
func StructByPoint(st *Student){//golang的数组与结构体不需要显式取内容st.Name = "里萨"st.Age = 25fmt.Printf("函数内该结构体实例的值为%#v\n",st)
}

调用

package mainimport ("fmt""go_learn/struct_knowledge"
)//这是入口文件
func main(){//指针类型传值var myStudent= new(struct_knowledge.Student)myStudent.Name = "张三"struct_knowledge.StructByPoint(myStudent)fmt.Printf("函数外该结构体实例的值为%#v\n",myStudent)
}

结果

函数内该结构体实例的值为&struct_knowledge.Student{Name:"里萨", Age:25}
函数外该结构体实例的值为&struct_knowledge.Student{Name:"里萨", Age:25}

传递结构体实例的指针可以修改外部实例。

注意事项

需要我们给结构体指针赋值时不需要使用*取结构体内容，例如

type Student struct{Name stringAge int
}
var student = new(Student)
student.Name = "张三"

但是他还是结构体指针类型，当我们需要传参时，如果参数要求的是值不是指针，那我们仍然需要*取结构体内容。

type Student struct{Name stringAge int
}
var MyStudent = new(Student)
MyStudent.Name = "张三"func Add(st Student){...
}//由于函数参数要结构体的值，所以需要结构体指针取值
Add(*MyStudent)

相应的如果函数要的是指针，我们就要传递指针，例如

type Student struct{Name stringAge int
}
//这里是值类型
var MyStudent Student
MyStudent.Name = "张三"//函数参数要求指针
func Add(st *Student){...
}//传递指针类型
Add(&MyStudent)