Go语言结构体struct详解，Go空结构体的这些妙用你知道吗？

03-02 1214阅读 0评论

本文详解了Go语言结构体的各个知识点，最后介绍了空结构体的3种妙用。希望对你有帮助。

Go语言结构体struct详解，Go空结构体的这些妙用你知道吗？,Go语言结构体struct详解，Go空结构体的这些妙用你知道吗？,词库加载错误:未能找到文件“C:\Users\Administrator\Desktop\火车头9.8破解版\Configuration\Dict_Stopwords.txt”。,使用,我们,访问,第1张
（图片来源网络，侵删）

定义

结构体，是一种自定义的数据类型，由多个数据类型组合而成。用于描述一类事物相关属性。

定义方式：

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}

注意：结构体指针必须手动初始化，分配内存地址

匿名结构体

适用于临时数据存储的场景

Go语言结构体struct详解，Go空结构体的这些妙用你知道吗？,Go语言结构体struct详解，Go空结构体的这些妙用你知道吗？,词库加载错误:未能找到文件“C:\Users\Administrator\Desktop\火车头9.8破解版\Configuration\Dict_Stopwords.txt”。,使用,我们,访问,第2张
（图片来源网络，侵删）
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。

方法与函数区别：函数不属于任何类型，方法属于特定类型。函数没有接收者，方法有接收者。

Go语言结构体struct详解，Go空结构体的这些妙用你知道吗？,Go语言结构体struct详解，Go空结构体的这些妙用你知道吗？,词库加载错误:未能找到文件“C:\Users\Administrator\Desktop\火车头9.8破解版\Configuration\Dict_Stopwords.txt”。,使用,我们,访问,第3张
（图片来源网络，侵删）

标准格式：

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 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/wangzhongyang007/goframe-shop-v2

      结构体与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 }{}
  // Receive a message from the worker.
  }) {
  // Receive a message from the main program.
  }
func methodUse() {
  t := T{}
  t.Print()
  t.Print2()
  //输出：
  //哈哈哈Print
  //哈哈哈Print2
}
func (t T) Print() {
  fmt.Println("哈哈哈Print")
}
func (t T) Print2() {
  fmt.Println("哈哈哈Print2")
}

相关阅读：

1、【微服务】java 规则引擎使用详解

2、C# List使用详解

3、SpringCloudConfig使用ssh方式连接GitHub报错JSchException: Auth fail的解决方案

4、【优质书籍推荐】《像程序员一样使用MySQL》

5、云原生微服务 第六章 Spring Cloud中使用OpenFeign

免责声明
本网站所收集的部分公开资料来源于AI生成和互联网，转载的目的在于传递更多信息及用于网络分享，并不代表本站赞同其观点和对其真实性负责，也不构成任何其他建议。
文章版权声明：除非注明，否则均为主机测评原创文章，转载或复制请以超链接形式并注明出处。

相关阅读

发表评论

快捷回复： 表情：
评论列表 （暂无评论，1214人围观）

还没有评论，来说两句吧...

目录[+]