本文详解了Go语言构造体的各个知识点，最初介绍了空构造体的3种妙用。心愿对你有帮忙。

定义

构造体，是一种自定义的数据类型，由多个数据类型组合而成。用于形容一类事物相干属性。

定义形式：

type 类型名 struct {    字段名 字段类型    …}//示例：type Animal struct {  Name string  Age  int}

实例化

构造体和构造体指针，两者的实例化有所区别

提供多种写法，灵便应用：

//构造体实例化//写法1//var a Animal //a.Name = "aaa"//a.Age = 18//写法2a := Animal{   Name: "dog",  Age:  18,}fmt.Println(fmt.Sprintf("%T - %v", a, a)) //main.Animal - {dog 18}//构造体指针实例化//写法1var 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)) //0v1 := 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. 须要批改接收者中的值
  2. 接收者是拷贝代价比拟大的大对象
  3. 保障一致性，在同一个文件中，如果有某个办法应用了指针接收者，那么其余的办法也倡议应用指针接收者

留神点：

1.接收者类型，能够是任何类型，不仅仅只针对构造体类型。但要留神下，类型和办法定义须要在同一个包上面

type MyInt intfunc (i MyInt) SayInt() {  fmt.Println("my type is MyInt")}func main() {  var i1 MyInt  i2 := MyInt(10)  i1.SayInt()  i2.SayInt()}输入后果：my type is MyIntmy 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，然而空构造体最为一个变量它的指针必定是占用内存空间的，只是单用很小。

因为空构造体的值不占据内存空间的个性，因而被宽泛作为各种场景下的占位符应用。

  1. 一是节俭资源
  2. 二是空构造体自身就具备很强的语义：即这里不须要任何值，仅作为占位符。

空构造体应用场景

次要应用场景有3个：

  1. 实现汇合类型
  2. 实现空通道
  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语言构造体的各种知识点，最初针对空构造体的作用和应用场景，进行了具体的解说。在之后的理论我的项目开发过程中，只用占位不必理论含意，那么咱们就都能够应用空构造体，能够极大的节俭不必要的内存开销。

心愿对大家有帮忙，兄弟们觉好留赞哦。