结构体(struct)是自定义方式形成新的数据类型，结构体是类型中带有成员的复合类型。Go 语言结构体是一种聚合的数据类型，是由零个或多个任意类型的值聚合成的实体。每个值称为结构体的成员。来描述真实世界的实体和实体对应的各种属性。
结构体属性也叫 字段 或 成员 ,每个字段都有名称和类型，每个名称是唯一的。可以是任何类型，如普通类型、复合类型、函数、map、interface、struct等，所以我们可以理解为go语言中的“类”。
定义
结构体定义方式如下：
- type name struct{
- fieldName1 type1
- fieldName2 type2
- ...
- }
如下，定义User 结构体：
- type User struct {
- Name string
- age int
- }
实例化
上面定义只是类型，就想是一个 int 一样，需要定义一个类型变量才可以使用，类似Java的类。
直接定义变量使用
- package main
-
- import (
- "fmt"
- )
-
- type User struct {
- Name string
- age int
- }
-
- func main() {
- var user1 User //定义User 类型变量user
- var user2 *User //类型指针，未分配内存，不能直接使用
- fmt.Println(user1, user2) //{ 0} <nil>
- }
定义默认成员变量
- var user1 = User{Name: "abc"}
- fmt.Println(user1)
- func NewUser() *User {
- return &User{Name:"abc",age:20}
- }
使用内建函数 new() 分配内存返回类型变量指针
- var user = new(User)
- fmt.Println(user) //&{ 0}
访问成员
使用 . 来访问
- var user User
- user.Name = "abc"
- user.age = 20
- fmt.Println(user) //{abc 20}
首字母大小写问题，成员大写表示包外可见(即面向对象的公有属性),小写包外不可见
零值：结构体的零值是 nil
初始值:结构体的初始值是非 nil 时，各成员对应类型的初始值
空结构体:空结构体就是没有字段的结构体，空结构体不占内存
- package main
-
- import (
- "fmt"
- "unsafe"
- )
-
- func main() {
- user1 := struct{}{}
- user2 := struct{}{}
- fmt.Printf("%p,%dn", &user1, unsafe.Sizeof(user1)) //0x585218,0
- fmt.Printf("%p,%dn", &user2, unsafe.Sizeof(user2)) //0x585218,0
- }
从上面可以看出空结构体内存地址和大小都是一样的。根据这个特性，使用空结构体可以作为信号量，起到信号作用但不占内存。如空结构体类型的 chan
匿名结构体
匿名结构体没有类型名称，无须通过 type 关键字定义就可以直接使用。
- user := struct {
- Name string
- }{Name: "abc"}
- fmt.Println(user) //{abc}
比较
如果结构体的全部成员都是 可以比较 的，且成员的 顺序 、 类型 、 数量 完全一样才可以比较，两个结构体将可以使用==或!=运算符进行比较。
- package main
-
- import (
- "fmt"
- )
-
- func main() {
- user1 := struct {
- Name string
- }{Name: "abc"}
- user2 := struct {
- Name string
- }{Name: "abc"}
- fmt.Println(user1 == user2) //true
- }
成员名称不一样
- package main
-
- import (
- "fmt"
- )
-
- func main() {
- user1 := struct {
- Name string
- }{Name: "abc"}
- user2 := struct {
- name string
- }{name: "abc"}
- fmt.Println(user1 == user2) //invalid operation: user1 == user2 (mismatched types struct { Name string } and struct { name string })
- }
成员数量不一样
- package main
-
- import (
- "fmt"
- )
-
- func main() {
- user1 := struct {
- Name string
- }{Name: "abc"}
- user2 := struct {
- Name string
- age int
- }{Name: "abc"}
- fmt.Println(user1 == user2) //invalid operation: user1 == user2 (mismatched types struct { Name string } and struct { Name string; age int })
- }
成员类型不能比较
- package main
-
- import (
- "fmt"
- )
-
- func main() {
- user1 := struct {
- Name string
- m map[int]int
- }{Name: "abc"}
- user2 := struct {
- Name string
- m map[int]int
- }{Name: "abc"}
- fmt.Println(user1 == user2) //invalid operation: user1 == user2 (struct containing map[int]int cannot be compared)
- }
顺序不一样
- package main
-
- import (
- "fmt"
- )
-
- func main() {
- user1 := struct {
- Name string
- age int
- }{Name: "abc"}
- user2 := struct {
- age int
- Name string
- }{Name: "abc"}
- fmt.Println(user1 == user2) //invalid operation: user1 == user2 (mismatched types struct { Name string; age int } and struct { age int; Name string })
- }
其实整个结构体就是一个类型(如int)，成员顺序、类型这些不一样，整体的结构体就不一样，故对于强类型语言来说就是不能比较的，对应类型完全一样还需要注意成员是否是可以比较，如slice、map等
Go语言没有面向对象这个概念，但可以把结构体看做是一个类，可以实现面向对象的特性，如通过组合和嵌入实现继承
匿名字段
匿名字段是结构体没有显示的名字，是结构体嵌入一个或多个结构体，如下面
B直接嵌入A ，B是匿名字段
- package main
-
- import (
- "fmt"
- )
-
- type A struct {
- Name string
- B
- }
- type B struct {
- Age int
- Name string
- }
访问成员变量
- func main() {
- var a = A{Name:"a",B:B{Name:"b",Age:20}}
- fmt.Printf("%#vn", a) //main.A{Name:"", B:main.B{Age:0}}
- fmt.Println(a.Name) //a
- fmt.Println(a.B.Name) //b
- fmt.Println(a.Age) //20
- }
只有一个成员名称的情况下，Go语法糖可以省略嵌入结构体
- fmt.Println(a.B.Age) //20
- fmt.Println(a.Age) //20
对应有多个相同名称的成员，不能省略，因为编译器不知道是哪个
- type C struct {
- A
- B
- }
-
- func main() {
- var c = C{A:A{Name:"a"},B:B{Name:"b",Age:20}}
- fmt.Println(c.Name) //ambiguous selector c.Name
- }
正确做法是
- func main() {
- var c = C{A:A{Name:"a"},B:B{Name:"b",Age:20}}
- fmt.Println(c.A.Name) //a
- fmt.Println(c.B.Name) //b
- }
组合
上面是没有名字的嵌入结构体，还可以给嵌入结构体命名,访问必须要带上具体的字段，不能省略。
- package main
-
- import (
- "fmt"
- )
-
- type A struct {
- Btype B
- }
- type B struct {
- Age int
- Name string
- }
-
- func main() {
- var a = A{Btype:B{Name:"b",Age:20}}
- fmt.Println(a.Name) //.Name undefined (type A has no field or method Name)
- }
标签
如下面在字段后面用 `` 包起来的是标签，主要是通过反射来序列化和反序列化，具体由反射章节来讲。
- type User struct {
- Id int `json:"id"`
- Account string `json:"account" form:"account"`
- Nickname string `gorm:"nickname" json:"nickname" form:"nickname"`
- }
方法
方法一般都是面向对象编程(OOP)的一个特性，Go语言的方法其实与一个值或变量关联的特殊的函数。这个值或变量叫做 接收者
- func ([typeName] 接收者) name (param) [return]{}
接收者是自定义的类型
- package main
-
- import (
- "fmt"
- )
-
- type A struct {} //结构体
-
- type B int //int
-
- func (a A) show() {
- fmt.Println("a............")
- }
-
- func (b B) show() {
- fmt.Println("b............")
- }
-
- func main() {
- var a A
- var b B
- a.show()
- b.show()
- }
接收者不能直接用内置类型
- func (c int) show() { //cannot define new methods on non-local type int
- fmt.Println("b............")
- }
接收者 值 可以是值类型或指针类型
- package main
-
- import (
- "fmt"
- )
-
- type A struct {}
-
- type B struct {}
-
- func (a A) show() { //值类型
- fmt.Println("a............")
- }
-
- func (b *B) show() { //指针类型
- fmt.Println("b............")
- }
-
- func main() {
- var a A
- var b B
- a.show()
- b.show()
- }
对与 B 来说,下面两种调用方式是等价的，本质上他们都是一样的， b.show() 的写法是省略了 (&b) ,只不过由语法糖来补全
- func main() {
- var b B
- b.show()
- (&b).show()
- }
方法可以访问接收者自身的信息，如下
- package main
-
- import (
- "fmt"
- )
-
- type User struct {
- Id int
- Account string
- Nickname string
- }
-
- func (u User)show() {
- fmt.Println(u.Nickname)
- }
-
- func main() {
- var a = User{Nickname:"测试"}
- a.show() //测试
- }
值类型接收者拷贝类型的全部，修改 不会 影响原数据;指针拷贝的是地址，修改 会 影响原数据
- package main
-
- import (
- "fmt"
- )
-
- type User struct {
- Id int
- Account string
- Nickname string
- }
-
- func (u User)show() {
- fmt.Println(u)
- }
- func (u User)setName1() {
- u.Nickname="值类型"
- }
-
- func (u *User)setName2() {
- u.Nickname="指针类型"
- }
-
- func main() {
- var a = User{Nickname:"测试"}
- a.setName1()
- a.show()
- a.setName2()
- a.show()
- }
接受者 类型 本身不能为指针
- package main
-
- import (
- "fmt"
- )
-
- type A int
-
- type B *int //变量类型为指针
-
- func (a A) show() {
- fmt.Println("a............")
- }
-
- func (b B) show() { //invalid receiver type B (B is a pointer type)
- fmt.Println("b............")
- }
