共计 5076 个字符，预计需要花费 13 分钟才能阅读完成。
本文详解了 Go 语言构造体的各个知识点，最初介绍了空构造体的 3 种妙用。心愿对你有帮忙。
定义
构造体，是一种自定义的数据类型，由多个数据类型组合而成。用于形容一类事物相干属性。
定义形式：
type 类型名 struct {
字段名 字段类型
…
}
// 示例：type Animal struct {
Name string
Age int
}实例化
构造体和构造体指针，两者的实例化有所区别
提供多种写法，灵便应用：
// 构造体实例化
// 写法 1
//var a Animal
//a.Name = "aaa"
//a.Age = 18
// 写法 2
a := Animal{
Name: "dog",
Age: 18,
}
fmt.Println(fmt.Sprintf("%T - %v", a, a)) //main.Animal - {dog 18}
// 构造体指针实例化
// 写法 1
var b *Animal
b = new(Animal)
// 写法 2
//b := new(Animal)
// 写法 3
//b := &Animal{}
b.Name = "cat" // 在底层是(*b).Name = "cat"，这是 Go 语言帮咱们实现的语法糖
fmt.Println(fmt.Sprintf("%T - %v", b, b)) //*main.Animal - &{cat 0}留神：构造体指针必须手动初始化，调配内存地址
匿名构造体
实用于长期数据存储的场景
var v struct {
Name string
Age int
}
fmt.Println(v)空构造体
不占用内存空间
var v struct{}
fmt.Println(unsafe.Sizeof(v)) //0
v1 := struct{}{}
fmt.Println(unsafe.Sizeof(v1)) //0构造函数
Go 没有自带的构造函数，采纳自实现
形式 1
构造体不简单，能够返回构造体类型，值拷贝性能开销小
func NewPerson(name string, age int8) Person {
return Person{
name: name,
age: age,
}
}定义形式 2
构造体简单，得返回构造体指针类型，防止值拷贝产生的性能开销
func NewPerson(name string, age int8) *Person {
return &Person{
name: name,
age: age,
sex: sex,
country:country,
province:province,
city:city,
town:town,
address:address,
}
}办法与接收者
办法（Method）是一种作用于特定类型变量的函数。这种特定类型变量叫做 接收者（Receiver）。接收者的概念就相似于 PHP 中的 this 或者 self。
办法与函数区别：函数不属于任何类型，办法属于特定类型。函数没有接收者，办法有接收者。
规范格局：
func (接收者变量 接收者类型) 办法名(参数列表) (返回参数) {函数体}接收者类型（两种）：
- 非指针类型：产生值拷贝产生正本，办法内批改字段，只在办法内失效；
- 指针类型：不产生正本，办法内批改字段，同步失效；
func NewPerson(name string, age int8) *Person {
return &Person{
name: name,
age: age,
}
}
func (p *Person) Dream() {
p.name = "aaa"
fmt.Printf("%s 的幻想是学好 Go 语言 \n", p.name) //aaa 的幻想是学好 Go 语言
}
func main() {p1 := NewPerson("小王子", 25)
p1.Dream()
fmt.Println(p1) //&{aaa 25}
}什么时候应用指针类型的接收者：
- 须要批改接收者中的值
- 接收者是拷贝代价比拟大的大对象
- 保障一致性，在同一个文件中，如果有某个办法应用了指针接收者，那么其余的办法也倡议应用指针接收者
留神点：
1. 接收者类型，能够是任何类型，不仅仅只针对构造体类型。但要留神下，类型和办法定义须要在同一个包上面
type MyInt int
func (i MyInt) SayInt() {fmt.Println("my type is MyInt")
}
func main() {
var i1 MyInt
i2 := MyInt(10)
i1.SayInt()
i2.SayInt()}
输入后果：my type is MyInt
my type is MyInt匿名字段
构造体容许其成员字段在申明时没有字段名而只有类型，这种没有名字的字段就称为匿名字段
type User struct {
Name string
Gender string
Address // 匿名字段
}
type Address struct {
Province string
City string
CreateTime string
}
func main() {
var u1 User
u1.Name = "张三"
u1.Gender = "男"
u1.Address.City = "北京" // 匿名字段默认应用类型名作为字段名
u1.CreateTime = "2019" // 匿名字段能够省略，但留神多个匿名字段下有雷同字段名，会编译失败，所以倡议不采纳省略写法
fmt.Println(u1)
}但须要留神字段名抵触问题，所以不倡议应用省略写法操作匿名字段
实现面向对象的“继承”个性
Go 不是面向对象编程的语言，但能够 通过嵌套构造体的形式，来实现面向对象的“继承”个性
type Animal struct {
Name string
Age int
}
func (a Animal) Say() {fmt.Println(fmt.Sprintf("1-my name is %s and age is %d", a.Name, a.Age))
}
type Cat struct {Animal // 嵌套构造体实现继承}
func main() {c1 := Cat{}
c1.Name = "加菲猫"
c1.Age = 5
c1.Say()
// 输入后果：//1-my name is 加菲猫 and age is 5
}子类还能够重写父类的Say 办法，并且还能领有本人的Run 办法：
func (c Cat) Say() {fmt.Println(fmt.Sprintf("2-my name is %s and age is %d", c.Name, c.Age))
}
func (c Cat) Run() {fmt.Println(fmt.Sprintf("my name is %s，还是跑步高手", c.Name))
}
func main() {c1 := Cat{}
c1.Name = "加菲猫"
c1.Age = 5
c1.Say()
c1.Run()
// 输入后果：//2-my name is 加菲猫 and age is 5
//my name is 加菲猫，还是跑步高手
}标签 tag
通过反射机制，辨认构造体的标签，容错能力较差，须要留神应用
规范格局：
`key1:"value1" key2:"value2"`应用注意事项：
- 外层应用
反引号包起来，里边 value 须要应用双引号包起来； - KV 之间应用
冒号，多个 KV 之间应用空格；（留神：冒号前后不要加其余符号）
应用示例：
goframe v2 的规范路由注册就是应用标签 tag 的形式定义的，大家感兴趣能够看下咱们开源我的项目的代码：
https://github.com/wangzhongy…
构造体与 JSON 系列化
给构造体增加 json 标签，而后做 json 序列化操作：
- 首字母大写字段（公开）：会转换成 json 标签指定的字段名，若未指定，则应用本身字段名；
- 首字小写字段（公有）：不会输入，因为这类字段仅在定义以后构造体的包中可拜访；
简略示例：
type CardInfo struct {
Title string `json:"title"`
Desc string
height int `json:"height"`
}
func main() {
c1 := CardInfo{
Title: "成长之星",
Desc: "balabala",
height: 100,
}
data, _ := json.Marshal(c1)
fmt.Println(string(data)) //{"title":"成长之星","Desc":"balabala"}
str := "{"title":"title111","desc":"desc222","height":20}"
c2 := CardInfo{}
_ = json.Unmarshal([]byte(str), &c2)
fmt.Println(c2) //{title111 desc222 0}
}空构造体
上文为大家简略介绍了 空构造体 ，应用unsafe.SizeOf() 办法，明确晓得了空构造体，它不占用存储空间。
（即“宽度”为 0，宽度形容了一个类型的实例所占用的存储空间的字节数）
s := struct{}{}
fmt.Println(unsafe.Sizeof(s)) //0在我的项目代码中，咱们常常都会看到空构造体 struct{}{} 的应用，它有什么作用，适宜什么场景应用呢？
空构造体作用
请大家留神：构造体蕴含一个指针和指针指向的数据，下文所说的不占用内存其实指的是指针指向的数据为 null，然而空构造体最为一个变量它的指针必定是占用内存空间的，只是单用很小。
因为空构造体的值不占据内存空间的个性，因而 被宽泛作为各种场景下的占位符应用。
- 一是节俭资源
- 二是空构造体自身就具备很强的语义：即这里不须要任何值，仅作为占位符。
空构造体应用场景
次要应用场景有 3 个：
- 实现汇合类型
- 实现空通道
- 实现办法接收者
上面一一为大家详解
1. 实现汇合类型
Go 语言自身是没有汇合类型（Set），通常是应用 map 来代替。
但有个问题：就是汇合类型，只须要用到 key（键），不须要用到 value（值）
如果 value 应用 bool 来示意，理论会占用 1 个字节的空间，为了节俭空间，这时空构造体就能够大显神通了
type Set map[int]struct{}
func main() {s := make(Set)
s.add(1)
s.add(2)
s.add(3)
s.remove(2)
fmt.Println(s.exist(1))
fmt.Println(s)
// 输入：//true
//map[1:{} 3:{}]
}
func (s Set) add(num int) {s[num] = struct{}{}
}
func (s Set) remove(num int) {delete(s, num)
}
func (s Set) exist(num int) bool {_, ok := s[num]
return ok
}空构造体作为占位符，不会额定减少不必要的内存开销，很不便的就把问题给解决了
2. 实现空通道
在 Go 语言 channel 的应用场景中，经常会遇到 告诉型 channel，其不须要发送任何数据，只是用于协调 Goroutine 的运行，用于流转各类状态或是管制并发状况。
这类状况就特地适宜应用空构造体，只做个占位，不节约内存空间
func main() {ch := make(chan struct{})
go worker(ch)
// Send a message to a worker.
ch <- struct{}{}
// Receive a message from the worker.
<-ch
println("AAA")
// 输入：//BBB
//AAA
}
func worker(ch chan struct{}) {
// Receive a message from the main program.
<-ch
println("BBB")
// Send a message to the main program.
close(ch)
}因为该 channel 应用的是空构造体，因而也不会带来额定的内存开销
3. 实现办法接收者
应用构造体类型的变量作为办法接收者，有时构造体能够不蕴含任何字段属性。这种状况，能够用 int 或者 string 来代替，但它们都会占用内存空间，所以应用空构造体是比拟适合的。
并且 也有利于将来针对该类型进行公共字段等的减少，容易扩大和保护
type T struct{}
func methodUse() {t := T{}
t.Print()
t.Print2()
// 输入：// 哈哈哈 Print
// 哈哈哈 Print2
}
func (t T) Print() {fmt.Println("哈哈哈 Print")
}
func (t T) Print2() {fmt.Println("哈哈哈 Print2")
}总结
本文详解了 Go 语言构造体的各种知识点，最初针对空构造体的作用和应用场景，进行了具体的解说。在之后的理论我的项目开发过程中，只用占位不必理论含意，那么咱们就都能够应用空构造体，能够极大的节俭不必要的内存开销。
心愿对大家有帮忙，兄弟们觉好留赞哦。
