开发者

Go语言的结构体还能这么用?看这篇就够了

目录
  • 定义
  • 实例化
  • 匿名结构体
  • 空结构体
  • 构造函数
    • 方式1
    • 定义方式2
  • 方法与接收者
    • 匿名字段
      • 实现面向对象的“继承”特性
        • 标签tag
          • 结构体与jsON系列化
            • 空结构体
              • 空结构体作用
                • 空结构体使用场景
                  • 1.实现集合类型
                  • 2.实现空通道
                  • 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,
                    }
                  }

                  python法与接收者

                  方法(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 //js嵌套结构体实现继承
                  }
                  
                  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,但是空结构体最为一个变量它的指针肯定是占用内存空间的,只是单用很小。

                  因为空结构体的值不占据内存空间的特性,因此被广泛作为各种场景下的占位符使用

                  • 一是节省资源
                  • 二是空结构体本身就具备很强的语义:即这里不需要任何值,仅作为占位符。

                  空结构体使用场景

                  主要使用场景有3个

                  • 实现集合类型
                  • 实现空通道
                  • 实现方法接收者

                  下面逐个为大家详解

                  1.开发者_Python实现集合类型

                  Go语言本身是没有集合类型(Set),通常是使用map来替代

                  但有个问题:就是集合类型,只需要用到key(键),不需要用到value(值)

                  如果value使用bool来表示,实际会占用1个字节的空间,为了节php省空间,这时空结构体就可以大显身手了

                  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来替代,但它们都会占用内存空间,所以使用空结构体是比较合适的。

                  并且也有利于未来针对该类型进php行公共字段等的增加,容易扩展和维护

                  type T strucpythont{}
                  
                  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语言结构体的各种知识点,最后针对空结构体的作用和使用场景,进行了详细的讲解。在之后的实际项目开发过程中,只用占位不用实际含义,那么我们就都可以使用空结构体,可以极大的节省不必要的内存开销。

                  参考链接:Go空结构体struct{}的作用是什么

                  以上就是Go语言的结构体还能这么用?看这篇就够了的详细内容,更多关于Go语言结构体的资料请关注我们其它相关文章!

                  0

                  上一篇:

                  下一篇:

                  精彩评论

                  暂无评论...
                  验证码 换一张
                  取 消

                  最新开发

                  开发排行榜